Модульность
Представьте программную систему, написанную в процедурном стиле, может быть в одном файле. Управление исполнением происходит с помощью прямой передачи управления оператором goto. Изменяя код в этой программе, вы рискуете сломать то поведение, которое не должно было измениться. Такая система становится хрупкой по отношению к изменениям в ней.
Поэтому все большие системы мы хотим разделить на маленькие части и тем самым снизить нашу боль при изменении программного кода. Мотивация у этого всегда одна и та же, мы хотим менять части нашей системы независимо друг от друга.
Внося правки в систему, которая сопротивляется изменениям, мы говорим, что связанность слишком высока. В таких случаях естественным для нас становится желание разорвать связанность внутри нашей программы.
Плохая модульность может быть и приобретенным явлением. Рост энтропии в проекте может привести к высокой связанности[high coupling] и низкой функциональной сплоченности[low cohesion].
Оказалось, что на практике объяснить разницу между coupling и cohesion сложно. Далеко не каждый понимает разницу и эта терминология вызывает больше вопросов чем ответов.
Для объяснения я воспользуюсь преимуществами русского языка (в котором coupling и cohesion переводятся как связанность) и крутым докладом Влада Хононова Balancing Coupling in Software Design DDD Europe 2023.
Что такое связанность?
Само слово связанность говорит нам о том, что компоненты имеют некоторую связь между собой. Но так ли плохо иметь эту связь?
Связь присутствует повсюду:
- Органы в нашем организме связанны между собой чтобы осуществлять нашу жизнедеятельность
- Наши города связаны между собой транспортными развязками
- Детали в самолёте связаны между собой, чтобы обеспечить возможность самолёту летать
- Детали в наших компьютерах связанны между собой, чтобы я мог написать этот курс, а вы могли прочитать его
- и т.д.
Невозможно построить систему из полностью развязанных компонентов. Если компоненты полностью разделены, это не система, это просто набор компонентов, не работающих для достижения всеобъемлющей цели. Общая ценность у таких компонентов околонулевая.
Поэтому вместо того чтобы пытаться отделить всё друг от друга, давайте примем тот факт, что связи важны для достижении всеобъемлющей цели.
Оси измерения связанности
Давайте предположим, что у нас есть два компонента. upstream и downstream. Downstream компонент зависит от upstream компонента.
Эта связь определяет как изменения в компоненте upstream влияют на компонент downstream. Изменения в upstream могут вызвать каскадные изменения в downstream и сломать его. Другими словами если вы вносите изменения в upstream, насколько велик риск изменения downstream?
Если риск сломать downstream изменениями в upstream высок, то такие компоненты называют сильно связанными.
Может показаться, что связанность либо есть, либо её нет. Но это не так. Связанность имеет три оси измерения:
- Сила
- Расстояние
- Изменчивость
Сила
Есть множество моделей определения силы связи, но только одну можно отнести к нашим современникам.
- Coupling in Structured Design - 1960 г
- Connascence - 1990 г
- Integration Strength - 2020 г
На ней и рассмотрим первую ось.
Integration Strength описывает 4 уровня силы от большего к меньшему:
Нужно понимать, что каждый из этих уровней имеет подуровни с различными силами связи.
Например:
Контрактная связанность может делиться на синхронную связанность и асинхронную (в зависимости от используемых контрактов).
Асинхронные связи, такие как: Event-Carried State Transfer, больше развязывают компоненты по сравнению с синхронными (но только для операций чтения).
Синхронные же связи могут быть реализованы с более слабыми контрактами и тем самым быть более развязанными.
Strict - контракты с жесткой схемой. Такие контракты на ранней стадии валидируют входящий/исходящий контракты, что повышает надежность и производительность. Некоторые из них имеют под собой описание вызываемых методов. Интеграционные тесты хорошо справляются с тестированием строгих контрактов.
Строгие контракты создают хрупкость в интеграционной архитектуре, чего следует избегать. То, что одновременно часто меняется и используется несколькими различными частями архитектуры, создает проблемы в архитектуре; контракты соответствуют этому описанию, потому что они образуют клей в распределенной архитектуре: чем чаще они должны меняться, тем больше проблем они вызывают для других сервисов.
Строгий контракт требует соблюдения имен, типов, порядка и всех других деталей, не оставляя двусмысленности. Примером максимально строгого контракта в программном обеспечении является удаленный вызов метода (пример из Java RMI). В этом случае удаленный вызов имитирует внутренний вызов метода, совпадающее имя, параметры, типы и все другие детали.
Loose - контракты с мягкой схемой. Как правило key/value поля с максимально мягкой валидацией или без нее совсем. Изменение такого контракта не потребует изменения на второй стороне, но риски поломки максимально велики. Для поддержания целостности таких контрактов используют Contract Testing. Такие контракты требуют высокого уровня зрелости команд работающих с ними.
Tunable - настраиваемый контракт. Имеет строгую схему и дает потребителю возможность запросить только те данные, которые ему нужны.
Нужно понимать, что как и многие вещи в архитектуре программного обеспечения, контракты существуют не в двоичном, а в широком спектре, от абсолютно строгого до полностью свободного.
Навязчивая связанность
Самый высокий уровень связи. такой уровень связи связывает компоненты на уровне:
- деталей реализации
- приватных интерфейсах
Такой уровень связывания хрупкий и неявный. Изменения в деталях реализации upstream компонента могут сломать downstream компоненты.
Хорошим примером такой связанности будет java|c# reflection для доступа к приватным методам или интеграция через базу данных.
Функциональная связанность
Означает, что связанные компоненты реализуют тесно связанные бизнес функции. Другими словами, одно и тоже бизнес требование затронет изменения связанных компонентов.
Связанность бизнес моделей
Означает что компоненты используют одну и ту же модель бизнес области.
Эту проблему хорошо изложил Мартин Фаулер у себя в блоге. Предложив концепцию ограниченных контекстов.
Когда мы идентифицируем домен, мы находим множество сущностей и поведений связанных с этим доменом.
Например, приложение может иметь домен под названием CatalogCheckout (каталог оформления заказов), который включает в себя такие понятия, как элементы каталога, клиенты и оплата и домен OrderFulfilment (исполнения заказа), который включает в себя такие понятия, как элементы каталога, клиенты.
В традиционной монолитной архитектуре мы бы создали классы повторного использования под каждую сущность и разрешили бы другим функциональностям использовать их. Что может привести к перегрузке классов определениями и сильной связанности системы.
В ограниченных контекстах мы бы инкапсулировали все сущности в пределах одного контекста оставив лишь внешний контракт. Все внутренная реализация (код, БД) не покидают границ контекста.
Представим еще более интересную и близкую нам ситуацию. Доменами CatalogCheckout и OrderFulfilment владеют разные команды и они разнесены по разным сервисам. Поскольку обе команды имеют одни и те же сущности (Item, Client) и похожие свойства, разработчики пытаются повторно использовать их в обоих сервисах, думая, что это сэкономит время и усилия. Вместо этого это увеличивает усилия, потому что изменения теперь должны распространяться между всеми командами, которые разделяют общий компонент. И всякий раз, когда их сервис меняется, разработчики должны беспокоиться об изменениях в общем компоненте. С другой стороны, если каждый сервис имеет свою собственную модель и передает необходимую информацию из CatalogCheckout в OrderFulfilment без связи с общим компонентом, он может измениться независимо.
Шаблон ограниченных контекстов лежит в основе современных, эффективных архитектурных стилей.
Контрактная связанность
Здесь компоненты отделены друг от друга с помощью строго определенной модели интеграции которая отделена от деталей реализации. Это означает, что реализация может изменяться, но эти изменения не повлияют на интеграционный контракт.
В целом разница в этих уровнях в том объёме знаний, которыми делится вышестоящий поток с нижестоящими.
Логично предположить, что навязчивая связанность самый вредный уровень связанности, а контрактная связанность самый полезный.
Но так ли это на сам деле?
Для того чтобы ответить на этот вопрос нам нужно рассмотреть второе измерение.
Расстояние
Связи между компонентами могут охватывать разное расстояние в кодовой базе. Связь может быть между:
- методами класса
- классами
- компонентами
- микросервисами
- системами
Чем дальше мы продвигаемся по уровню абстракции, тем больше расстояние.
Если на горизонтальной оси находится расстояние между компонентами, то на вертикальной оси стоимость изменений. Чем расстояние между компонентами выше, тем стоимость изменений выше. Чем больше расстояние, тем больше усилий нам необходимо приложить для координации и это очевидно потребует больше времени.
Отсюда видно, что модификация двух методов в одном классе обойдется нам сильно дешевле по сравнению с изменениями в разных системах.
Стоимость изменений пропорциональна расстоянию между компонентами.
Самое интересное, что расстояние зависит не только от расположения компонентов в кодовой базе, но и от организационной структуры.
Давайте представим, что у нас есть два микросервиса в одной команде и два микросервиса в разных командах. С двумя командами у нас определенно выше накладные расходы на координацию, если нам нужно модифицировать их для достижения какой-то всеобъемлющей цели.
Давайте рассмотрим еще один пример.
Представим, что у нас есть две системы, функционально связанные между собой. Дистанция между ними большая.
- Можем ли мы считать это плохим дизайном?
- Как мы любим говорить: "Это зависит от ...".
А зависит это от изменчивости/волатильности?
Волатильность
Третей осью измерения является совместная изменчивость компонентов.
Конечно предсказать будущее не просто, но опираясь на знание бизнеса мы попробуем это сделать.
Хорошими источниками вдохновения могут служить:
- business building blocks
- поддомены или бизнес возможности
- Согласованные варианты использования
Поиск баланса или уменьшение боли
И теперь когда мы рассмотрели все три оси которые влияют на связанность, настало время подумать как же нам использовать эти знания. Как, зная эти оси, выбирать взвешенное решение относительно связанности наших компонентов.
Подойдём к этой проблеме математически и опишем функцию боли.
Боль = ƒ(S, D, V) - где боль это функция от силы, расстояния, волатильности
- S - сила
- D - расстояние
- V - волатильность
Наша функция это произведение её аргументов.
Боль = Сила * Расстояние * Волатильность
Big ball of mud
- Что будет если все аргументы функции будут иметь высокие значения?
Связи между компонентами у которых все три оси имеют высокие уровни обычно называют big ball of mud или distributed big ball of mud (для распределенных систем).
Уровень боли при работе с такими компонентами запредельный (особенно в распределенных системах). Изменение upstream приводит к каскадным изменениям в downstream'ах.
[Distributed] Big ball of mud = высокая сила * большое расстояние * высокая совместная волатильность
Coupling
Coupling - это мера того, насколько связанны два компонента.
Loose coupling = низкая сила * большое расстояние * низкая совместная волатильность.
Coupling это устоявшийся термин для компонентов у которых низкая совместная волатильность и большое расстояние.
Cohesion
Cohesion - эта мера того насколько компоненты функционально связанны. Считается, что cohesion должен быть высоким.
Чем выше сила, тем больше вероятность каскадных изменений. Чем выше волатильность тем чаще нам придётся учитывать эти каскадные изменения. Но т.к. расстояние минимально, затраты на координацию изменений будут минимальны и, соответственно, уровень боли тоже.
High cohesion = большая сила * маленькое расстояние * высокая совместная волатильность.
Интересным образом понижение(ухудшение) cohesion влияет на увеличение(ухудшение) coupling и наоборот. Эти два определения имеют обратную корреляцию, увеличение одного понижает другое. Например, если в вашей системе high coupling, у вас будет low cohesion. Объяснить это можно так: высокая связанность (coupling) говорит нам о том, что в системе низкая функциональная сплоченность.
Прагматичные отношения
При отсутствии каких либо изменений в системе, боли мы не почувствуем. То, чего нет - болеть не может. Такое может быть допустимо, когда у вас есть легаси приложение, которое никогда не дорабатывается. Зайти и прочитать из БД при интеграции с такой системой может быть вполне безболезненно.
Прагматичные отношения = большая сила * большое расстояние * низкая совместная волатильность.
Универсальный совет
Алгоритм минимизации боли заключается в том чтобы максимально исключить все случайные знания которые передаются через границы upstream компонента.
Контрактная связанность решает большинство наших проблем, Но мы, как дизайнеры, зачастую, должны уметь работать с тем, что есть. Манипулируйте аргументами нашей функции, снижайте возможные боли в будущем.
Драйверы модульности
Архитекторы не должны разбивать систему на более мелкие части, если нет четких бизнес-факторов. Основными бизнес-факторами для разбиения приложений на более мелкие части являются скорость выхода на рынок(time-to-market) и достижение уровня конкурентного преимущества на рынке(competitive advantage).
Time-to-market достигается благодаря архитектурной гибкости - способности быстро реагировать на изменения. Гибкость(Agility) - это сложная архитектурная характеристика, состоящая из многих других характеристик архитектуры, maintainability, testability и deployability.
Competitive advantage достигается за счет скорости выхода на рынок в сочетании с масштабируемостью, доступностью и отказоустойчивостью приложений. Чем лучше работает компания, тем больше она растет, отсюда потребность в большей масштабируемости для поддержки возросшей активности пользователей. Отказоустойчивость, способность приложения выходить из строя и продолжать работать, необходима для обеспечения того, чтобы по мере сбоя частей приложения, другие части по-прежнему могли функционировать в обычном режиме, сводя к минимуму общее воздействие на конечного пользователя.
Я уже ранее говорил про Quality Attribute. Рассмотрим их подробнее.
Maintainability
Maintainability - это простота добавления, изменения или удаления функций, а также применение внутренних изменений, таких как инфраструктурные обновления, патчи безопасности, обновления платформы, обновления сторонних производителей и так далее.
Относительными метриками качества эволюционности могут служить:
- Component coupling. Степень и то, как много компоненты знают друг о друге.
- Component cohesion. Степень и способ взаимодействия операций компонента между собой.
- Cyclomatic complexity. Общий уровень косвенности и вложенности внутри компонента.
Technical vs. domain partitioning. Компоненты скомпонованы по техническому использованию или бизнес цели домена.
Technical partitioning - разделение происходит по техническому принципу. Как правило это используемый стек или внешние используемые компоненты.
Domain partitioning - разделение происходит по бизнес потребностям. При таком разделение компоненты компонуются вокруг бизнес домена, а не стека разработки.
Пример
Крупные монолитные архитектуры, не использующие модульные подходы, как правило, имеют низкий уровень эволюционности из-за технического разделения функциональности на слои, тесной coupling между компонентами и слабой cohesion компонентов с точки зрения домена.
Рассмотрим новое требование в рамках традиционной монолитной многослойной архитектуры о добавлении срока действия к товарам, содержащимся в списке желаний клиента (элементы в списке, которые, возможно, можно приобрести позже).
Область изменений нового требования находится на уровне приложения, поскольку изменение распространяется на все уровни в приложении. В зависимости от структуры команды, внедрение этого простого изменения для добавления срока действия к элементам списка желаний в монолитной многоуровневой архитектуре может потребовать координации по крайней мере 3 различных команд
С другой стороны, модульные архитектуры разбивают домены и поддомены на более мелкие, отдельно развернутые единицы программного обеспечения, тем самым облегчая изменение домена или поддомена.
Testability
Тестируемость определяется как простота тестирования (обычно реализуемая с помощью автоматизированных тестов), а также полнота тестирования.
Например
Рассмотрим приложение, которое было разбито на три небольших автономных блока (сервиса). Внесение изменений в сервис A ограничивает область тестирования только этим сервисом, так как сервис B и сервис C не coupled с сервисом A. Однако по мере увеличения связи между этими сервисами, возможность тестирования быстро снижается, потому что область тестирования для изменения в сервисе A теперь включает в себя сервис B и сервис C, что влияет как на простоту тестирования, так и на полноту тестирования.
Deployability
Развертываемость - это не только простота развертывания, но и частота развертывания и общий риск развертывания. Чтобы поддерживать гибкость и быстро реагировать на изменения, приложения должны поддерживать все три этих фактора.
Scalability
Масштабируемость определяется как способность системы оставаться отзывчивой по мере постепенного увеличения нагрузки с течением времени. С масштабируемостью связана эластичность, которая определяется как способность системы оставаться отзывчивой во время значительно высоких, мгновенных и неустойчивых скачков нагрузки от потребителей на систему.
Availability/Fault Tolerance
Архитектурная модульность имеет важное значение для достижения отказоустойчивости на уровне домена и функциональности в системе. Разбивая систему на несколько блоков развертывания, катастрофический сбой изолируется только от этого блока развертывания, что позволяет остальной части системы функционировать нормально. Однако в этом есть предостережение - если другие сервисы синхронно зависят от сбоя сервиса, то отказоустойчивость не достигается. Это одна из причин, по которой асинхронная связь между сервисами необходима для поддержания хорошего уровня отказоустойчивости в распределенной системе.
Ссылки:


















