Почему «просто добавить функцию» иногда означает переделать полсистемы

 

 

 

 

 

ПРОЕКТИРОВАНИЕ // DEPENDENCY_IMPACT

Стоимость новых функций

«Добавьте ещё одну функцию».

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

Кажется, что речь идёт об одной небольшой доработке.

Но в работающей информационной системе почти не бывает изменений, которые существуют изолированно.

Новая функция ⟳База данныхAPIБизнес-логикаИнтерфейсИнтеграция с ERPУведомленияОтчётностьПрава доступа

Новый статус может затронуть базу данных, API, бизнес-логику, интерфейс, интеграцию с ERP, уведомления, отчётность и права доступа. Новый способ оплаты — финансовый контур, возвраты, сверку платежей, договоры с провайдерами и бухгалтерскую отчётность. Новый тип клиента может повлиять на расчёт цены, CRM, документы и правила маршрутизации.

В результате задача, которая выглядит как «добавить одно поле», превращается в изменение нескольких связанных компонентов.

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

ДИАГНОЗ // EVOLUTION_LIMITS

Это не обязательно означает, что система плохо написана.

> Чаще проблема в другом: требования бизнеса растут быстрее, чем архитектура успевает адаптироваться к этим изменениям.

 

АРХИТЕКТУРА // COUPLING_COMPLEXITY

Программный продукт меняется не по одному месту

Представим простую систему заказов.

В ней есть: заказ → клиент → товар → оплата → доставка

На раннем этапе всё может быть достаточно просто. Затем бизнес начинает развиваться.

Появляются:

РАСШИРЕНИЕ // EVOLVING_REQUIREMENTS
  • › несколько типов клиентов;
  • › разные способы оплаты;
  • › возвраты;
  • › частичные отгрузки;
  • › несколько складов;
  • › программы лояльности;
  • › интеграция с ERP;
  • › мобильное приложение;
  • › личный кабинет;
  • › новые каналы продаж.

Каждое требование само по себе кажется небольшим.

Но система уже состоит из множества взаимосвязанных решений.

НОВОЕ ТРЕБОВАНИЕБизнес-логикаБаза данныхAPIИнтерфейсОтчётыИнтеграцииКлиентскийсценарийАналитикаERP / CRM

Изменение не обязательно большое.

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

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

 

ЭВОЛЮЦИЯ // ARCHITECTURAL_HISTORY

Почему в новой системе изменить что-то проще

Когда продукт только создаётся, архитектура ещё не связана историческими решениями.

Разработчики могут свободно определить:

ПРОЕКТИРОВАНИЕ // GREENFIELD_FREEDOM
  • › структуру данных;
  • › границы модулей;
  • › интерфейсы между компонентами;
  • › правила доступа;
  • › формат API;
  • › способы обработки ошибок;
  • › механизмы интеграции.

Но по мере эксплуатации система накапливает решения.

НАСЛОЕНИЯ // ACCUMULATED_DECISIONS
  • › Некоторые из них были приняты осознанно.
  • › Другие появились как временные.
  • › Третьи были оптимальными несколько лет назад, но перестали соответствовать текущим требованиям.
  • › Четвёртые возникли из-за ограничений внешних систем.
  • › Пятые появились просто потому, что бизнесу нужно было выпустить функцию вчера.

Постепенно архитектура начинает отражать не только первоначальный замысел, но и всю историю развития продукта.

> И именно здесь возникает технический долг.

 

ОПРЕДЕЛЕНИЕ // TECHNICAL_DEBT_NATURE

Технический долг — это не просто «плохой код»

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

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

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

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

Первоначально сэкономленное время превращается в будущую стоимость изменений.

Быстрое решениеМеньше затрат сегодняАрхитектура получает ограничениеПоявляются новые требованияИзменение затрагивает больше компонентовРастёт стоимость следующего изменения

Поэтому технический долг — не обязательно ошибка.

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

Проблемой он становится тогда, когда компания перестаёт контролировать размер и последствия этого обязательства.

 

МЕТРИКИ // CHANGE_COST_DRIVERS

Почему стоимость изменений растёт

Стоимость функции зависит не только от объёма кода, но и от числа компонентов, которые необходимо проверить и изменить.

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

ФОРМУЛА // COST_EQUATION
стоимость изменения = анализ требований и зависимостей + разработка + тестирование + миграция данных + адаптация интеграций + внедрение + сопровождение и управление рисками

На ранней стадии большая часть этой формулы может быть небольшой.

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

Например, изменение поля status может потребовать проверить:

ОБЛАСТЬ_ПРОВЕРКИ // IMPACT_RADIUS_CHECK
  • › бизнес-логику;
  • › API;
  • › мобильное приложение;
  • › отчёты;
  • › интеграцию с CRM;
  • › интеграцию с ERP;
  • › уведомления;
  • › права доступа;
  • › фоновые задачи;
  • › исторические данные.
[ ИЗМЕНЕНИЕ ]
Само изменение может занять несколько часов.
[ ВАЛИДАЦИЯ ]
Но проверить, что изменение не нарушило существующее поведение системы, может потребовать значительно больше времени. Чем шире область влияния изменения и слабее автоматизированные проверки, тем больше усилий требуется для регрессионного тестирования.

 

ЗАВИСИМОСТИ // COUPLING_IMPACT

Чем больше связей, тем дороже изменение

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

Теперь представим компонент, которым пользуются:

ПОТРЕБИТЕЛИ_КОМПОНЕНТА // COMPONENT_DEPENDENTS
  • › пять внутренних сервисов;
  • › мобильное приложение;
  • › внешний API;
  • › интеграция с ERP;
  • › аналитический контур.

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

ЗАКОН_СВЯЗАННОСТИ // ARCHITECTURAL_LAW

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

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

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

 

УГРОЗЫ // SHADOW_DEPENDENCIES

Самая опасная зависимость — скрытая

Явную зависимость обычно обнаружить несложно.

Например, сервис A вызывает API сервиса B. Это можно увидеть в архитектурной документации, коде или конфигурации.

Скрытые зависимости обнаружить сложнее, поскольку они не описаны в интерфейсах компонентов или документации.

КЕЙСЫ // HIDDEN_CONTRACTS
  • › другой сервис не вызывает API напрямую, но читает общую таблицу и зависит от её структуры, значений полей или внутренних правил обновления данных;
  • › отчёт предполагает, что определённый статус заказа означает конкретное бизнес-состояние;
  • › внешняя система ожидает, что поле никогда не будет пустым.
АНАЛИЗ_СВЯЗЕЙ // UNTRACKED_COUPLING

Формально компоненты могут выглядеть независимыми.

> Фактически они связаны контрактом, который нигде не описан.

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

 

ПРОЦЕССЫ // STATE_MACHINE_EVOLUTION

Почему «одно поле» иногда становится большой задачей

Рассмотрим типичный пример.

Бизнес говорит:

«Добавим заказу новый статус — “Ожидает подтверждения”».

В базе данных добавить значение относительно просто. Но что дальше?

Нужно определить:

АНАЛИЗ_СОСТОЯНИЯ // STATE_IMPACT_CHECKLIST
  • › кто может установить этот статус;
  • › из каких состояний в него можно перейти;
  • › в какие состояния можно перейти после него;
  • › что происходит с оплатой;
  • › нужно ли уведомлять клиента;
  • › появляется ли задача у сотрудника;
  • › что показывает CRM;
  • › что передаётся в ERP;
  • › учитывается ли заказ в отчётах;
  • › можно ли отгрузить такой заказ;
  • › что увидит мобильное приложение;
  • › как обрабатываются старые заказы.

Получается уже не изменение поля.

Это изменение состояния бизнес-процесса.

БЫЛО:Новый → В работе → Оплачен → Отгружен → ЗавершёнСТАЛО:НовыйВ работеОжидает подтвержденияОплаченОтгружен

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

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

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

 

ЭВОЛЮЦИЯ_РИСКОВ // ACCUMULATED_CONSTRAINTS

Архитектурные ограничения появляются постепенно

Архитектурные проблемы обычно накапливаются постепенно.

Обычно ограничения накапливаются.

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

Первоначальная модельНовое требованиеНебольшое исключениеЕщё одно требованиеВторое исключениеНовый каналДополнительная логикаСложная система условийИзменения становятся дорогими

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

 

ОГРАНИЧЕНИЯ_КОНТУРА // ARCHITECTURAL_MISALIGNMENT

Архитектура может перестать соответствовать бизнесу

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

Через несколько лет она уже работает с:

БИЗНЕС_МАСШТАБИРОВАНИЕ // ENTERPRISE_REALITY
  • › несколькими рынками;
  • › разными типами клиентов;
  • › несколькими юридическими лицами;
  • › несколькими каналами продаж;
  • › сложными тарифами;
  • › партнёрами;
  • › внешними API;
  • › большим количеством интеграций.

А внутри продолжает жить архитектура, рассчитанная на первоначальный сценарий.

Тогда разработчики вынуждены постоянно добавлять исключения.

КРИТИЧЕСКИЙ_СИГНАЛ // BOTTLENECK_DETECTED

Это важный сигнал:

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

 

ЭКОНОМИКА_ДОЛГА // DEBT_REFAC_MANAGEMENT

Не всякий технический долг нужно погашать

Здесь тоже легко впасть в крайность. Увидеть старый код и решить «сначала всё перепишем» — не обязательно хорошая стратегия.

Полное переписывание системы редко является целью само по себе.

У технического долга должна быть экономическая оценка. Стоит спросить:

АУДИТ_ДОЛГА // REFACTORING_QUESTIONS
  • › Как часто этот участок меняется?
    Если компонент практически не меняется, его несовершенная архитектура может не создавать существенных затрат.
  • › Сколько изменений он блокирует?
    Если один старый компонент мешает развитию нескольких ключевых функций, его приоритет значительно выше.
  • › Насколько дорого каждое изменение?
    Если каждое новое требование требует длительного анализа и регрессионного тестирования, необходимо оценить, какая часть затрат связана с объективной сложностью задачи, а какая — с архитектурными ограничениями. Это помогает определить, оправдан ли рефакторинг и какой участок даст наибольший эффект.
  • › Какой риск несёт существующее решение?
    Иногда проблема не в скорости разработки, а в надёжности, безопасности или невозможности масштабирования.
  • › Есть ли понятный момент для изменения архитектуры?
    Иногда правильнее не делать отдельный большой проект, а менять проблемный участок постепенно вместе с развитием функциональности.

 

РИСКИ // PATCH_OVERLOADING

Когда «ещё одна заплатка» становится опасной

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

Это кажется дешевле. И иногда действительно дешевле.

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

Через несколько итераций появляется слой условий:

СЛОЙ_УСЛОВИЙ // ACCUMULATED_IF_STATEMENTS
  • › если клиент такого типа — делаем так;
  • › если заказ пришёл из этого канала — делаем иначе;
  • › если старая интеграция — используем отдельный сценарий;
  • › если дата раньше определённого момента — применяем старое правило.

Система продолжает работать.

Но стоимость понимания этой системы начинает расти.

А это тоже технический долг.

 

ЭКСПЛУАТАЦИЯ // HIDDEN_RESOURCES_COST

Самый дорогой ресурс — иногда не разработка

В зрелом enterprise-продукте значительная часть стоимости изменения может приходиться не на написание кода.

Необходимо:

ПРОЦЕССЫ_ИЗМЕНЕНИЯ // OVERHEAD_OPERATIONS
  • › понять существующую архитектуру;
  • › найти зависимости;
  • › проверить контракты;
  • › согласовать изменение;
  • › подготовить миграцию;
  • › обновить интеграции;
  • › провести регрессионное тестирование;
  • › проверить данные;
  • › организовать релиз;
  • › проконтролировать работу после внедрения.

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

[ ПЕРВАЯ СИСТЕМА ]
Одна имеет понятные границы и слабую связанность.
[ ВТОРАЯ СИСТЕМА ]
Другая представляет собой сеть исторически сложившихся зависимостей.

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

 

ДИАГНОСТИКА // DEGRADATION_SIGNALS

Как понять, что архитектура уже начинает мешать

Есть несколько характерных признаков.

СИМПТОМЫ // ARCHITECTURAL_RED_FLAGS
  • › Новая функция регулярно затрагивает несколько несвязанных модулей:
    Если практически любое изменение требует правок в пяти-десяти местах, стоит проверить границы компонентов.
  • › Разработчики боятся менять старый код:
    Не потому, что код старый, а потому, что неизвестно, что от него зависит.
  • › Регрессионное тестирование растёт быстрее функциональности:
    Каждая новая функция требует всё большего набора проверок.
  • › Появляются специальные исключения:
    Вместо общей бизнес-логики постоянно добавляются условия для отдельных клиентов, каналов или сценариев.
  • › Интеграции становятся хрупкими:
    Изменение одного внутреннего объекта неожиданно ломает внешний обмен.
  • › В компании есть «незаменимые» специалисты:
    Если только один человек знает, почему определённый компонент работает именно так, это не только кадровый риск. Это архитектурный сигнал.
КРИТИЧЕСКИЙ_СИМПТОМ // DANGEROUS_PATTERN

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

 

ПРОЕКТИРОВАНИЕ // CHANGE_RESILIENCE

Архитектура должна выдерживать изменения

Архитектура не может заранее учитывать все будущие требования. Её задача — позволять вносить ожидаемые изменения без необходимости каждый раз перестраивать несвязанные части системы.

ЗАДАЧА // DESIGN_GOAL

Задача архитектуры другая:

— сделать наиболее вероятные изменения относительно дешёвыми и локальными.

ПРИНЦИПЫ_ИЗОЛЯЦИИ // CHANGE_LOCALIZATION
  • › Если изменение каталога товаров не должно затрагивать механизм авторизации, эти части системы желательно разделить.
  • › Если новый канал продаж не должен переписывать финансовый контур, между ними должен существовать понятный контракт.
  • › Если изменение внутренней реализации сервиса не должно ломать десятки клиентов API, интерфейс сервиса должен быть отделён от его внутреннего устройства.

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

 

ПРОЕКТИРОВАНИЕ // COUPLING_TYPES

Слабая связанность — не абстрактная теория

Термин «слабая связанность» иногда звучит как академическая архитектурная теория.

На практике это очень конкретная экономическая характеристика.

Если изменение компонента A требует обязательно менять B, C, D и E, система сильно связана.

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

СИЛЬНАЯ СВЯЗАННОСТЬ:
ABCDE
СЛАБАЯ СВЯЗАННОСТЬ:
APIABCDE

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

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

ПРАВИЛО // COMPLEXITY_MANAGEMENT

Архитектура не убирает сложность.

— Она переносит её в управляемое место.

 

ИНТЕГРАЦИИ // INTEGRATION_OVERHEAD

Почему интеграции особенно быстро увеличивают стоимость изменений

Каждая внешняя система добавляет контракт.

РАЗНОРОДНОСТЬ_КОНТРАКТОВ // EXTERNAL_CONTRACTS
CRM ожидает:
один формат.
ERP —
другой.
Платёжная система —
третий.

Мобильное приложение использует API.

Партнёр подключён к ещё одному интерфейсу.

РАДИУС_ПОРАЖЕНИЯ // INTERNAL_CHANGE_RISK

Теперь изменение внутренней модели данных нельзя рассматривать только внутри одного приложения.

> Нужно проверить, какие внешние потребители от неё зависят.

Поэтому при росте количества интеграций особенно важны:

ТРЕБОВАНИЯ // COMPONENT_STABILITY
  • › стабильные API с явно определённым поведением;
  • › версионирование при несовместимых изменениях;
  • › чёткие контракты;
  • › документированные контракты взаимодействия;
  • › преобразование данных на границах систем;
  • › согласованные правила обработки ошибок и повторных запросов;
  • › мониторинг интеграций и контроль задержек;
  • › сохранение обратной совместимости на период перехода потребителей на новую версию.

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

 

ПРОЕКТИРОВАНИЕ // BOUNDARY_REFACTORING

Иногда проблему нужно решать не кодом, а изменением границ

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

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

РАЗДЕЛЕНИЕ // BOUNDARY_EXAMPLES
  • › каталог товаров может развиваться отдельно от расчёта платежей;
  • › управление клиентами — отдельно от логистики;
  • › уведомления — отдельно от основного бизнес-процесса.

Но выделять отдельный сервис только потому, что «микросервисы — это современно», тоже неправильно.

Каждая дополнительная граница создаёт собственную сложность:

СЛОЖНОСТЬ_ИНФРАСТРУКТУРЫ // OVERHEAD_COSTS
  • › сетевые вызовы;
  • › отказоустойчивость;
  • › мониторинг;
  • › согласованность данных;
  • › управление версиями;
  • › необходимость диагностики;
  • › дополнительные затраты на эксплуатацию.

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

 

МЕТОДОЛОГИЯ // RECOVERY_STRATEGY

Что делать, когда требования уже обогнали архитектуру

Первый шаг — не переписывать всё.

Сначала нужно понять, где именно находится ограничение. Полезно построить карту:

Бизнес-функцииКомпоненты системыЗависимостиИнтеграцииДанные и контракты

После этого можно увидеть участки, которые:

ПРИОРИТЕТЫ // FOCUS_AREAS
  • › меняются чаще всего;
  • › имеют слишком много зависимостей;
  • › блокируют развитие;
  • › содержат большое количество исключений;
  • › создают высокий операционный риск.

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

 

МЕТОДОЛОГИЯ // REFACTORING_STRATEGY

Рефакторинг и переписывание — не одно и то же

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

Часто безопаснее идти постепенно.

Например:

анализ зависимостей → определение целевого контракта → создание нового интерфейса → постепенный перенос логики → проверка совместимости и результатов → переключение потребителей → наблюдение за работой → вывод старого компонента из эксплуатации

Такой подход позволяет менять архитектуру одновременно с развитием продукта.

Он сложнее, чем «сделать новую систему с нуля», но существенно снижает риск остановить бизнес-процессы.

Для работающего enterprise-продукта это часто критически важно.

 

ИТОГ // CHANGE_COST_CONTROL

Стоимость изменения можно контролировать

Нельзя сделать систему, в которой любое будущее изменение будет дешёвым.

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

Для этого архитектуру необходимо регулярно проверять по нескольким направлениям:

НАПРАВЛЕНИЯ_ПРОВЕРКИ // ARCHITECTURAL_HEALTH_DIRECTIONS
  • › Изменяемость.
    Какие компоненты меняются чаще всего?
  • › Связанность.
    Сколько других компонентов приходится затрагивать?
  • › Контракты.
    Насколько безопасно менять внутреннюю реализацию?
  • › Данные.
    Можно ли изменить модель без разрушительных миграций?
  • › Интеграции.
    Есть ли стабильные интерфейсы между системами?
  • › Тестируемость.
    Можно ли быстро доказать, что изменение не сломало существующее поведение?
  • › Наблюдаемость.
    Можно ли понять, что произошло после релиза?

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

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

 

ИТОГ // FINAL_RESOLUTION

Главное — не путать рост продукта с деградацией архитектуры

Большая система не обязана быть плохой.

Сложный бизнес закономерно приводит к сложной информационной системе.

Проблема начинается не тогда, когда в системе много компонентов.

КРИЗИС // ARCHITECTURAL_COMPLEXITY

> Проблема возникает, когда изменения бизнес-процессов требуют всё больше обходных решений, затрагивают несвязанные компоненты и становятся слишком дорогими в разработке и проверке.

Поэтому фраза «нам нужно добавить ещё одну функцию» должна восприниматься не как вопрос количества кода.

Нужно понимать:

СПИСОК_КОНТРОЛЯ // IMPACT_ANALYSIS_LIST
  • › что именно меняется в бизнес-процессе;
  • › какие компоненты отвечают за этот процесс;
  • › какие зависимости существуют;
  • › какие контракты затрагиваются;
  • › какие данные изменятся;
  • › и насколько локальным может остаться изменение.

Если функция действительно локальна — её и нужно делать локально.

Если она затрагивает фундаментальную модель продукта, лучше признать это на этапе проектирования, чем маскировать архитектурную проблему ещё одним исключением.

Потому что технический долг редко становится дорогим в момент своего появления.

Он становится дорогим тогда, когда каждое следующее изменение начинает платить за решения, принятые раньше.

Именно поэтому архитектуру стоит оценивать не только по тому, насколько хорошо система работает сегодня.

ФУНДАМЕНТ // CORE_QUESTION

Не менее важный вопрос:

— «сколько будет стоить изменить её завтра?»

 

НАВИГАЦИЯ // SUGGESTED_READING
 
[ Модуль // РАЗРАБОТКА ]

Как понять, что программу пора переписывать

 
[ Модуль // АРХИТЕКТУРА ]

Монолит или микросервисы?

 
[ Модуль // РАЗРАБОТКА ]

Когда готового программного обеспечения уже недостаточно

 
[ EXPERTISE JOURNAL ]

Все инженерные материалы и экспертные статьи

 
[ CORE GLOSSARY ]

Полный алфавитный справочник ИТ-терминов

AI Ассистент
×
ИИ может ошибаться