<?xml version="1.0" encoding="UTF-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <title>Tune IT</title>
  <link rel="self" href="" />
  <subtitle>Tune IT</subtitle>
  <id />
  <updated>2026-11-21T03:27:09Z</updated>
  <dc:date>2026-11-21T03:27:09Z</dc:date>
  <entry>
    <title>Справляемся с деградацией контекста ИИ-агента: передача сессии</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21330343" />
    <author>
      <name>Maxim Kalabukhov</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21330343</id>
    <updated>2026-11-10T13:34:38Z</updated>
    <published>2026-11-10T13:32:00Z</published>
    <summary type="html">&lt;p&gt;Во время длительной работы с ИИ-агентом можно столкнуться с неприятной ситуацией: после нескольких удачных шагов он начинает упускать требования, возвращаться к проверенным гипотезам и предлагать изменения, которые пользователь уже отклонил. Разработчик напоминает об ограничениях, прикладывает дополнительные пояснения и просит ещё раз проверить результат. История взаимодействия растёт вместе с количеством исправлений. Такое поведение может быть связано с тем, как модель использует накопленный контекст. В этой статье я рассмотрю причины возникновения проблемы и предложу способ организации длительной работы через передачу задачи агенту в новой сессии.&lt;/p&gt;

&lt;p&gt;Контекст ИИ-агента включает инструкции, сообщения пользователя, предыдущие ответы, содержимое прочитанных файлов и результаты вызовов инструментов. Управляющая система собирает эти данные и передаёт модели при формировании очередного ответа. От состава входных данных зависит, какие требования и факты окажутся доступны на следующем шаге.&lt;/p&gt;

&lt;p&gt;У каждого контекстного окна есть ограничение по объёму. При этом качество использования информации может снижаться ещё до достижения технического лимита. Термином «деградация контекста» обычно описывают подобное ухудшение работы с накопленной информацией. Для практической работы с агентами это означает, что доступный объём окна следует учитывать вместе с качеством его содержимого.&lt;/p&gt;

&lt;p&gt;При разработке программного обеспечения история быстро наполняется промежуточными данными. Агент читает исходный код, получает журналы ошибок, проверяет предположения, меняет реализацию и запускает тесты. Каждый шаг добавляет сведения, полезность которых со временем меняется. После исправления ошибки её старый стек вызовов может занимать значительную часть истории. Отклонённое решение продолжает присутствовать рядом с действующими договорённостями. Результаты проверки относятся к определённой версии кода, которая уже могла измениться.&lt;/p&gt;

&lt;p&gt;Представим задачу по оптимизации поиска заказов. Пользователь просит сохранить формат ответа API и существующие правила сортировки. Агент изучает запросы к базе данных, проверяет загрузку связанных сущностей и экспериментирует с пагинацией. Через некоторое время первоначальные ограничения оказываются окружены большим количеством технических подробностей. Если агент затем предлагает изменить структуру ответа или повторяет уже проверенный эксперимент, разработчик получает повод оценить состояние контекста.&lt;/p&gt;

&lt;p&gt;Один из способов управлять этой ситуацией заключается в передаче работы другому агенту в новой сессии. Текущий исполнитель фиксирует актуальное состояние задачи и подготавливает материалы для продолжения.&lt;/p&gt;

&lt;p&gt;Новый агент может использовать ту же модель, инструкции и инструменты. Он получает подготовленное описание задачи и доступ к рабочим материалам. Дальнейшее изучение проекта происходит по мере необходимости.&lt;/p&gt;

&lt;p&gt;Подобный принцип применяется в системах для длительной автономной работы. Anthropic описывает организацию последовательных сессий через сохранение результатов в файлах состояния. Следующий агент читает эти материалы, проверяет окружение и выбирает очередной участок работы.&lt;/p&gt;

&lt;p&gt;На практике такую передачу можно организовать с помощью передаточного документа. Перед завершением текущего диалога следует попросить агента сохранить состояние работы в отдельном файле, например &lt;code&gt;HANDOFF.md&lt;/code&gt;. Документ должен находиться в каталоге, доступном следующему исполнителю.&lt;/p&gt;

&lt;p&gt;В документе важно зафиксировать актуальную цель и ограничения пользователя. За время обсуждения требования могли измениться, поэтому следующему исполнителю нужна их действующая версия. Особое внимание стоит уделить поздним уточнениям, которые повлияли на выбранный подход.&lt;/p&gt;

&lt;p&gt;Описание текущего состояния должно объяснять, что уже выполнено, какие файлы изменены и какая работа остаётся. Для проекта под управлением Git полезно указать ветку, текущий коммит и наличие незакоммиченных изменений. Эти сведения связывают текст документа с конкретным состоянием проекта.&lt;/p&gt;

&lt;p&gt;Существенные решения также стоит сохранить вместе с их причинами. Если определённый вариант загрузки связанных сущностей привёл к дублированию строк при пагинации, документ должен описывать обнаруженный эффект и условия его возникновения. Это поможет следующему агенту учитывать результаты предыдущего исследования.&lt;/p&gt;

&lt;p&gt;Неподтверждённые предположения необходимо обозначить как гипотезы. Открытые вопросы и ближайший шаг завершают описание состояния и задают точку продолжения.&lt;/p&gt;

&lt;p&gt;Для подготовки передачи можно использовать короткий запрос:&lt;/p&gt;

&lt;pre&gt;
&lt;code&gt;Подготовь передачу текущей задачи в новую сессию.

Сохрани состояние работы в файле HANDOFF.md в корне проекта.
Зафиксируй актуальную цель, требования пользователя
и действующие ограничения.

Опиши выполненные изменения, затронутые файлы и оставшуюся
работу. Укажи рабочую ветку, текущий коммит и незакоммиченные
изменения, если эти сведения доступны.&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Перед закрытием сессии разработчику стоит прочитать полученный документ. В первую очередь полезно проверить цель, ограничения и степень готовности результата. Агент мог пропустить уточнение пользователя, переоценить результат проверки или неточно описать незавершённое изменение. Исправления на этом этапе помогут следующему исполнителю получить согласованное описание.&lt;/p&gt;

&lt;p&gt;После сохранения документа в работу вступает новая сессия с пустым контекстом. Для новой сессии достаточно одного предложения:&lt;/p&gt;

&lt;pre&gt;
&lt;code&gt;Прочитай /workspace/orders/HANDOFF.md и приступай к работе.&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Такой запуск предполагает, что передаточный документ содержит сведения, необходимые для продолжения. Следующий агент читает его, знакомится с рабочими материалами и восстанавливает состояние задачи. При обнаружении расхождений между описанием и файлами потребуется уточнить фактическое состояние проекта.&lt;/p&gt;

&lt;p&gt;Подготовку передачи удобно выполнять на границе содержательных этапов: после исследования проблемы, завершения изменения или получения результатов тестирования. В эти моменты проще описать достигнутое состояние и определить дальнейшее действие.&lt;/p&gt;

&lt;p&gt;При длительной работе документ полезно обновлять по мере продвижения. Тогда подготовка следующей передачи опирается на уже записанные решения и результаты. Это особенно важно, если к концу сессии качество использования накопленной истории вызывает сомнения.&lt;/p&gt;

&lt;p&gt;Любая передача сопровождается риском потери деталей. Сохранённое описание может содержать пропуски или ошибочные выводы, поэтому исходные требования, код и результаты проверок должны оставаться доступными. Следующий агент получает возможность уточнять сведения и проверять основания предыдущих решений.&lt;/p&gt;

&lt;p&gt;Передаточный документ позволяет сохранять рабочее состояние задачи между сессиями. Качество продолжения зависит от точности этого описания, доступности исходных материалов и проверки фактического состояния проекта новым исполнителем.&lt;/p&gt;</summary>
    <dc:creator>Maxim Kalabukhov</dc:creator>
    <dc:date>2026-11-10T13:32:00Z</dc:date>
  </entry>
  <entry>
    <title>State management в интерфейсах: Как понять, что происходит с данными</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21327688" />
    <author>
      <name>Алексей Кондратьев</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21327688</id>
    <updated>2026-11-04T11:43:21Z</updated>
    <published>2026-11-04T11:30:00Z</published>
    <summary type="html">&lt;p&gt;Любой интерфейс — это не просто набор красивых кнопок и карточек. Это сцена, на которой разворачивается непрерывный спектакль с участием данных. Данные приходят из ниоткуда, загружаются, трансформируются, куда-то исчезают и появляются вновь. И от того, насколько хорошо понятен этот поток, зависит, будет ли интерфейс казаться живым и предсказуемым — или превратится в источник тревоги и раздражения.&lt;/p&gt;

&lt;p&gt;State management (управление состоянием) — это дисциплина о том, как данные живут внутри интерфейса. Глубокое погружение в Redux, MobX или Zustand — задача для разработчиков, но базовое понимание того, как данные текут, какие состояния они порождают и как эти состояния проектировать, необходимо каждому, кто создаёт цифровые продукты. Потому что именно на этом уровне рождается пользовательский опыт.&lt;/p&gt;

&lt;h2&gt;Откуда берутся данные и куда они текут&lt;/h2&gt;

&lt;p&gt;Типичный экран списка задач. Что происходит, когда пользователь его открывает? Приложение отправляет запрос на сервер, сервер возвращает JSON с массивом задач, приложение сохраняет этот массив в памяти, а затем отображает его на экране. Каждое из этих действий — звено в цепочке потока данных.&lt;/p&gt;

&lt;pre class="brush:jscript;"&gt;
[Пользователь] → [Запрос к API] → [Сервер] → [Ответ JSON] → [Память приложения] → [Экран]&lt;/pre&gt;

&lt;p&gt;Данные могут приходить из разных источников: из ответа API, из локального хранилища браузера, из пользовательского ввода, из глобального состояния приложения (например, данные авторизованного пользователя, доступные на всех экранах), из URL (параметры запроса определяют, какие данные загружать), из WebSocket-соединения в реальном времени. Понимание этого многообразия — первый шаг к проектированию устойчивого интерфейса. Стоит задавать себе вопрос: откуда этот компонент получает свои данные? Могут ли они измениться, пока пользователь смотрит на экран? Что произойдёт, если источник данных недоступен?&lt;/p&gt;

&lt;p&gt;Состояние — это не монолит. Оно складывается из множества отдельных фактов, и каждый из них может жить своей жизнью. Часть состояния существует только внутри компонента: например, открыто ли меню фильтра, обычно важно только самому меню. Другие факты нужны нескольким частям интерфейса: выбранный фильтр определяет и выделенную кнопку, и содержимое списка. Если фильтр записан в адресе страницы, пользователь может открыть ту же подборку по ссылке или вернуться к ней кнопкой «Назад». У каждого значимого факта полезно определить источник истины — место, из которого интерфейс узнаёт актуальное значение. Если карточка показывает «Отменён», а экран деталей всё ещё предлагает отменить тот же заказ, стоит выяснить, откуда каждая часть интерфейса берёт статус и как получает его обновления.&lt;/p&gt;

&lt;p&gt;Некоторые значения можно вычислить из уже известных фактов, и тогда хранить их отдельно не нужно. Например, счётчик результатов можно получить из списка, если этот список содержит все результаты. Хранить счётчик отдельно имеет смысл, только если сервер возвращает общее число, а на экране показана лишь одна страница. В первом случае отдельная копия создаёт риск рассинхронизации, во втором — общее число и количество видимых карточек отвечают на разные вопросы.&lt;/p&gt;

&lt;h2&gt;Состояния, которые создают опыт&lt;/h2&gt;

&lt;p&gt;Любой компонент, работающий с данными, проходит через несколько состояний. Их нужно не просто знать — их нужно проектировать. Потому что если нарисован только идеальный экран с заполненными данными, спроектирована лишь малая часть реальности.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Состояние загрузки&lt;/strong&gt; — это момент, когда данные запрошены, но ещё не пришли. Как выглядит интерфейс в этот момент? Пустой экран? Спиннер? Скелетон-экран с пульсирующими заглушками?&lt;/p&gt;

&lt;p&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/21107385/Screenshot+from+2026-11-04+14-35-08.png/2d4425c5-a7d6-41da-3fe4-9875df8ebc24?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p&gt;Исследования показывают, что skeleton screens создают иллюзию скорости и снижают воспринимаемое время ожидания. Но важно не просто выбрать визуальный приём, а понять контекст: если данные загружаются дольше двух секунд, нужен индикатор прогресса. Если меньше — скелетон может быть достаточным. А может быть, стоит показать кэшированные данные, если они есть, и обновить их в фоне? Это уже проектное решение, которое влияет на ощущение скорости.&lt;/p&gt;

&lt;p&gt;Один и тот же индикатор может означать разные вещи. При первом открытии пользователю пока нечего просматривать — можно показать каркас карточек или индикатор рядом с текстом «Загружаем заказы». При повторном обновлении уже есть данные, с которыми можно работать: карточки можно оставить на месте, а индикатор разместить рядом с кнопкой обновления или заголовком. При отправке запроса на отмену одного заказа ожидание относится к конкретной операции — кнопка может показать «Отменяем…» и стать недоступной для повторного нажатия, но остальные заказы при этом можно продолжать просматривать. Размещение индикатора и текст рядом с ним должны отражать эту разницу.&lt;/p&gt;

&lt;p&gt;Полезно отдельно проверить порядок событий. Пользователь успел выбрать «В пути», а затем «Доставлены». Ответ для первого фильтра пришёл позже ответа для второго. На экране должны остаться доставленные заказы, потому что именно этот фильтр выбран сейчас. Чтобы описать такое поведение, достаточно зафиксировать правило: &lt;strong&gt;результат на экране должен соответствовать текущему выбору пользователя.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Состояние ошибки&lt;/strong&gt; — это момент, когда что-то пошло не так. Сервер вернул 500, сеть пропала, пользователь ввёл некорректные данные.&lt;/p&gt;

&lt;p&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/21107385/Screenshot+from+2026-11-04+14-36-16.png/8ea61c9d-f3fb-2c72-cd9a-0dc2826dd205?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p&gt;Хороший дизайн ошибки — это не красная плашка «Что-то пошло не так». Это сообщение, которое помогает понять причину и предлагает выход. «Не удалось загрузить список задач. Проверьте соединение и попробуйте снова» — это лучше, чем «Ошибка 500». Но ещё лучше — показать кнопку «Обновить» прямо в сообщении. Ошибка должна быть действием, а не тупиком.&lt;/p&gt;

&lt;p&gt;Последний случай особенно важен. Обрыв связи после отправки запроса оставляет открытой возможность, что система успела выполнить действие. Поэтому перед проектированием кнопки «Повторить» стоит узнать, можно ли безопасно отправить тот же запрос ещё раз и как проверить его результат. Для загрузки списка и для операции с заказом ответ может быть разным.&lt;/p&gt;

&lt;p&gt;У ошибки есть и масштаб. Ошибка поля относится к полю. Ошибка загрузки одного блока относится к блоку. Сообщение на весь экран уместно, когда без успешного результата пользователь действительно не может продолжить работу на этом экране. Выбор масштаба определяет, сколько полезного контекста сохранится после сбоя.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Пустое состояние&lt;/strong&gt; — это момент, когда данные успешно загружены, но их нет. Это не ошибка. Это нормальная ситуация, которая может возникать по разным причинам: пользователь только что зарегистрировался и ещё ничего не создал, поиск не дал результатов, фильтры слишком узкие.&lt;/p&gt;

&lt;p&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/21107385/Screenshot+from+2026-11-04+14-36-59.png/59fecca1-00a8-8409-9232-2979b7e2f679?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p&gt;Пустое состояние — это возможность для диалога. Объясните, почему здесь пусто, и предложите следующее действие. «У вас пока нет задач. Создайте первую!» — это не просто текст, это приглашение к действию, которое снижает тревогу и направляет пользователя.&lt;/p&gt;

&lt;p&gt;Стоит отдельно проверить доступ. Если человеку нельзя просматривать заказы команды, сообщение «Заказов пока нет» даст ему неверное представление о данных. Если продукт допускает объяснение ограничения, лучше показать, что просмотр недоступен, и указать, как получить доступ, когда такая возможность предусмотрена.&lt;/p&gt;

&lt;p&gt;Помимо этих трёх базовых состояний есть и другие, которые часто остаются без внимания. Состояние частичной загрузки, когда некоторые данные пришли, а некоторые ещё грузятся:&lt;/p&gt;

&lt;p&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/21107385/Screenshot+from+2026-11-04+14-37-34.png/3da12137-a6d6-bc27-d090-e310ce4e63ae?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p&gt;Состояние устаревших данных, когда информация на экране уже неактуальна, но всё ещё отображается. Состояние переходного процесса, когда пользователь нажал кнопку и ждёт результата, но ещё не знает, увенчается ли действие успехом. Каждое из этих состояний — отдельная проектная задача.&lt;/p&gt;

&lt;h2&gt;Почему AI пока не справляется с этим полностью&lt;/h2&gt;

&lt;p&gt;Может показаться, что нейросети, которые уже умеют генерировать целые интерфейсы по текстовому описанию, должны легко справляться и с состояниями. Но на практике это не так. AI отлично генерирует идеальный экран с заполненными данными:&lt;/p&gt;

&lt;p&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/21107385/Screenshot+from+2026-11-04+14-38-02.png/0197ae2f-57ca-6afa-6c6d-98be1e8b46f4?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p&gt;Он может добавить спиннер, если попросить. Но он не понимает контекста. Он не знает, что для этого конкретного списка задач важнее показать кэшированные данные, чем скелетон. Он не догадается, что пустое состояние после поиска должно отличаться от пустого состояния при первом входе. Он не спроектирует переход между состояниями так, чтобы пользователь не терял контекст. Он не учтёт, что ошибка загрузки одного блока не должна разрушать весь экран, а должна локализоваться и позволить остальному интерфейсу оставаться функциональным.&lt;/p&gt;

&lt;p&gt;AI может быстро составить черновой перечень состояний, предложить тексты ошибок или превратить сценарий в таблицу. Его удобно использовать и для проверки крайних случаев — например, попросить перечислить, что может произойти, пока пользователь ждёт подтверждения отмены и одновременно открывает детали другого заказа. Но для выбора поведения нужны факты о продукте. Можно ли показывать вчерашний список? Может ли запрос на отмену исполниться после обрыва связи? Как система подтверждает результат? Что потеряет пользователь, если форму придётся заполнять заново? Какие действия разрешены его роли? AI может помочь сформулировать эти вопросы и сопоставить варианты, но ответы зависят от правил продукта, поведения системы и того, чего пользователь ожидает в этой ситуации.&lt;/p&gt;

&lt;p&gt;Всё это требует эмпатии, понимания пользовательских сценариев и способности видеть интерфейс как живой организм, который меняется во времени. AI видит статичные снимки. Человек видит фильм. И именно это делает умение проектировать состояния таким ценным навыком.&lt;/p&gt;

&lt;h2&gt;Как проектировать состояния системно&lt;/h2&gt;

&lt;p&gt;Вместо того чтобы рисовать один экран и надеяться, что разработчики сами додумают остальное, стоит попробовать следующий подход.&lt;/p&gt;

&lt;p&gt;Начать с вопроса: какие данные нужны этому компоненту и откуда они приходят? Затем перечислить все возможные состояния: загрузка, успех, ошибка, пустота, частичная загрузка, устаревшие данные. Для каждого состояния нарисовать макет. Не просто описать словами, а именно нарисовать — как выглядит экран, какие элементы остаются, какие исчезают, какие появляются. Затем подумать о переходах: как компонент попадает из одного состояния в другое? Есть ли анимация? Есть ли задержка? Есть ли возможность отменить действие?&lt;/p&gt;

&lt;p&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/21107385/Screenshot+from+2026-11-04+14-38-33.png/7dc275b8-3085-a45a-05d3-59c5603c07fc?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p&gt;И наконец, проверить макеты на реальных сценариях. Что произойдёт, если интернет пропал в момент загрузки? Что увидит пользователь, если сервер вернёт ошибку через 10 секунд? Как будет выглядеть экран, если данные загрузятся, но окажутся пустыми? Эти вопросы кажутся очевидными, но именно на них чаще всего нет ответа в дизайн-макетах.&lt;/p&gt;

&lt;p&gt;В этой таблице список может быть одновременно заполненным и обновляющимся. Ошибка обновления тоже может сосуществовать с карточками. Поэтому при проектировании полезно разнести два вопроса: &lt;strong&gt;какие данные уже есть &lt;/strong&gt;и&lt;strong&gt; что сейчас происходит с запросом или действием&lt;/strong&gt;. Так становятся заметны сценарии, которые легко потерять, если рисовать только четыре отдельных макета «загрузка», «успех», «пусто» и «ошибка».&lt;/p&gt;

&lt;p&gt;Для интерактивного компонента есть ещё уровень самого управления. У кнопки могут быть состояния фокуса с клавиатуры, нажатия, недоступности и ожидания подтверждения. Здесь важна причина. Если кнопка «Отменить заказ» недоступна, потому что заказ уже отправлен, объяснение должно быть доступно рядом с кнопкой или в статусе заказа. Если человек уже нажал её и запрос выполняется, уместнее показать ход операции. В обоих случаях кнопка временно или постоянно недоступна, но для пользователя смысл разный.&lt;/p&gt;

&lt;p&gt;Перед передачей в разработку полезно пройти несколько коротких сценариев в прототипе или прямо по таблице. Открыть экран при медленной загрузке. Дважды сменить фильтр до получения ответа. Повторить запрос после ошибки. Проверить, что после сбоя остались введённые данные и понятно, куда двигаться дальше. Такие проверки показывают, где макет оставляет важное решение открытым.&lt;/p&gt;

&lt;h2&gt;Заключение&lt;/h2&gt;

&lt;p&gt;Понимание state management — это не про код. Это про то, чтобы видеть интерфейс не как картинку, а как процесс. Как последовательность состояний, каждое из которых имеет значение. Тот, кто проектирует все состояния компонента — от загрузки до ошибки, от пустоты до частичной готовности — создаёт продукт, который кажется надёжным и заботливым. Пользователь не замечает этой работы, но он её чувствует. Он чувствует, что интерфейс его понимает. И это ощущение — самое ценное, что может дать дизайн.&lt;/p&gt;

&lt;p&gt;Поэтому ценность навыка проектирования состояний особенно заметна в переходах. Макет показывает, как выглядит карточка заказа. Спроектированное поведение объясняет, что произойдёт, если статус изменится, запрос зависнет или ответ придёт после смены фильтра. В каждом из этих моментов интерфейс должен ясно показывать, что системе уже известно, чего она ещё ждёт и что пользователь может сделать сейчас.&lt;/p&gt;</summary>
    <dc:creator>Алексей Кондратьев</dc:creator>
    <dc:date>2026-11-04T11:30:00Z</dc:date>
  </entry>
  <entry>
    <title>Введение в архитектуру ПО. Практикум: привычный репозиторий и путь к инверсии зависимостей</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21327400" />
    <author>
      <name>Romo Fedoroff</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21327400</id>
    <updated>2026-11-03T23:42:06Z</updated>
    <published>2026-11-03T19:01:00Z</published>
    <summary type="html">&lt;style type="text/css"&gt;article p {
font-size:11pt;
font-family:Verdana, sans-serif;
text-align:justify;
color:#6a6a6a;
}

article img {
width: 90%;
}

article li {
 font-size:11pt;   
}

.centered {
text-align:center;
}


article .portlet-msg-info {
color: #232323;
background-color: #f9f9f9;
border-style: dashed;
border-color: #232323;
}

article code {
  font-size: 90%;
  color: #433ec9;
  word-wrap: break-word;
  font-weight: 600;
}
&lt;/style&gt;
&lt;h2&gt;Введение&lt;/h2&gt;

&lt;p&gt;Данная статья - практикум к серии «Введение в архитектуру ПО». Речь в ней пойдёт об инверсии зависимостей: как этот приём выглядит в обычном проекте на Java и Spring -&amp;nbsp;распространённом фреймворке для серверных приложений.&lt;/p&gt;

&lt;p&gt;Дальше в статье часто упоминаются&amp;nbsp;два термина: бизнес-правила и хранилище. Давайте дадим им определение.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Бизнес-правила&lt;/strong&gt; (их ещё называют бизнес-логикой) - код, который принимает решения по условиям задачи: можно ли записать пользователя ещё на один учебный курс, если он уже проходит три, положена ли покупателю скидка, пора ли закрывать заказ. Сами условия придумывает не программист. Их задают те, кто отвечает за продукт, исходя из того, как устроено дело, которое обслуживает приложение.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Хранилище&lt;/strong&gt; - код, который кладёт данные в базу и достаёт их обратно. В проекте на Java это класс или интерфейс с методами вроде «найти по идентификатору», «сохранить», «удалить».&lt;/p&gt;

&lt;p&gt;Правилам почти всегда нужно хранилище. Чтобы решить, можно ли записать пользователя на курс, надо сначала узнать, на сколько курсов он уже записан, а это знает только база. В упрощённом виде такой код выглядит так:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
class EnrollmentRules {

    private final PostgresParticipationStore store;

    EnrollmentRules(PostgresParticipationStore store) {
        this.store = store;
    }

    boolean canEnroll(long userId) {
        return store.countActiveCourses(userId) &amp;lt; 3;
    }
}
&lt;/pre&gt;

&lt;p&gt;В классе &lt;code&gt;EnrollmentRules&lt;/code&gt; находится правило «не больше трёх активных курсов». &lt;code&gt;PostgresParticipationStore&lt;/code&gt; - класс хранилища: он отправляет SQL-запрос в базу PostgreSQL и возвращает число. Имя этого класса стоит в коде правил дважды: в типе поля и в параметре конструктора. О такой связи говорят, что правила &lt;strong&gt;зависят&lt;/strong&gt; от хранилища: без класса &lt;code&gt;PostgresParticipationStore&lt;/code&gt; файл с правилами не скомпилируется, а любое изменение в объявлениях его методов отзовётся в правилах.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Инверсия зависимостей&lt;/strong&gt; переворачивает эту связь. Правила сами объявляют интерфейс - перечень операций, которые им нужны, - и дальше работают только с ним:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
// Объявлен в том же пакете, что и правила
interface ParticipationStore {
    int countActiveCourses(long userId);
}

class EnrollmentRules {

    private final ParticipationStore store;

    EnrollmentRules(ParticipationStore store) {
        this.store = store;
    }

    boolean canEnroll(long userId) {
        return store.countActiveCourses(userId) &amp;lt; 3;
    }
}
&lt;/pre&gt;

&lt;p&gt;Класс &lt;code&gt;PostgresParticipationStore&lt;/code&gt; никуда не делся, и SQL-запрос в нём прежний. Поменялось его объявление: теперь это &lt;code&gt;class PostgresParticipationStore implements ParticipationStore&lt;/code&gt;. Класс хранилища реализует интерфейс, который составили правила, то есть содержит код всех его методов.&lt;/p&gt;

&lt;p&gt;Сравним два листинга. Во время работы приложения правила по-прежнему вызывают хранилище, и запрос по-прежнему уходит в базу - здесь ничего не изменилось. Изменилось другое: чьё имя записано в чьём коде. Раньше код правил упоминал класс хранилища. Теперь он его не упоминает вовсе, а код хранилища, наоборот, упоминает интерфейс правил. Зависимость развернулась против направления вызова - отсюда и название приёма.&lt;/p&gt;

&lt;p&gt;Даёт это две вещи. Первая: правилам можно передать любой класс, который реализует интерфейс. В работающем приложении это настоящее хранилище, а в тесте - хранилище в памяти, то есть обычный список объектов. Тогда для проверки правила «не больше трёх» не придётся «поднимать базу», то есть запускать сервер базы данных ради теста. Вторая: хранилище можно переписать - поменять запрос, перейти на другую базу, - и файл с правилами даже не придётся открывать, пока интерфейс остаётся прежним.&lt;/p&gt;

&lt;p&gt;В предыдущей&amp;nbsp;статье в блоге из серии статей про архитектуру, этот приём разобран подробно, и разбор там заканчивается оговоркой: «Приём несложен. Возможно, поэтому его часто применяют формально, не получая обещанного результата». Обещанный результат - те две вещи, что названы абзацем выше. Формальное применение - это когда интерфейс в коде есть, а правила всё равно привязаны к устройству базы: интерфейс объявлен не рядом с правилами, тянет за собой типы фреймворка или открывает правилам операции, которые им не нужны. Как такое получается в живом проекте и как этого избежать - давайте об этом и поговорим.&lt;/p&gt;

&lt;p&gt;В проекте на Spring приём сразу упирается в вопрос, которого в схеме выше нет. Класс хранилища там обычно не пишут вовсе. Вместо него объявляют интерфейс-наследник &lt;code&gt;JpaRepository&lt;/code&gt; из библиотеки Spring Data, и при запуске приложения библиотека сама создаёт класс, который этот интерфейс реализует. В созданном классе сразу есть готовые операции с таблицей: сохранить объект в строку, найти строку по идентификатору, удалить, посчитать строки, выдать список по страницам - всего около трёх десятков.&lt;/p&gt;

&lt;p&gt;Отсюда и вопрос: если правила объявят собственный интерфейс, что делать с готовыми операциями? Отказаться от них и написать хранилище руками? Как-то связать свой интерфейс с тем, что создаёт библиотека? Или ничего не менять? От ответа зависит, сколько кода придётся написать и потом поддерживать и сколько сведений о базе - имён таблиц, колонок, связей между ними - останется в коде правил.&lt;/p&gt;

&lt;p&gt;Мы разберём три варианта ответа на одном сквозном примере.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Привычный&lt;/strong&gt; - тот, что получается в проекте на Spring сам собой: интерфейс Spring Data подключается прямо к коду правил, собственного интерфейса у правил нет.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;С отдельной моделью&lt;/strong&gt; - разделение до конца. Моделью называют набор классов, которыми приложение описывает свои данные. Здесь у правил своя модель - собственные классы без единого упоминания таблиц и колонок, - а вдобавок собственный интерфейс к хранилищу.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Переходный&lt;/strong&gt; - промежуточный между ними: собственный интерфейс у правил уже есть, а классы данных остаются теми же, что описывают таблицы.&lt;/p&gt;

&lt;p&gt;Для каждого варианта посмотрим, что он даёт и во что обходится. Затем - как выбрать вариант для нового проекта, как сделать, чтобы разделение не стёрлось через полгода правок, и как перейти от одного варианта к другому, не останавливая работу над задачами.&lt;/p&gt;

&lt;h2&gt;Задача&lt;/h2&gt;

&lt;p&gt;Пример для всей статьи - образовательная платформа. Устроена она так.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Программа&lt;/strong&gt; - описание курса: чему учат и в каком порядке. &lt;strong&gt;Запуск курса&lt;/strong&gt; - конкретная группа, которая проходит программу в свои даты: например, «Java для начинающих, группа с 1 марта». У одной программы бывает много запусков. &lt;strong&gt;Пользователь&lt;/strong&gt; записывается на запуск; «записаться на курс» на платформе означает именно это: записаться на конкретный запуск. Каждая &lt;strong&gt;запись&lt;/strong&gt; находится в одном из трёх состояний: активная (человек учится), отменённая (передумал) или пройденная (закончил курс).&lt;/p&gt;

&lt;p&gt;На записи действуют два правила. Первое: &lt;strong&gt;одновременно активных курсов у пользователя не больше трёх&lt;/strong&gt;, и попытка записаться на четвёртый заканчивается отказом. Второе: &lt;strong&gt;запись на пройденный курс отменить нельзя&lt;/strong&gt;. Правила короткие, но по каждому приложение принимает решение - записать или отказать, отменить или нет, - и это делает их бизнес-правилами в том смысле, что дан во введении.&lt;/p&gt;

&lt;p&gt;Есть на платформе и задача, в которой ничего не решается: экран «мои курсы» показывает пользователю его записи с названиями программ. Здесь ничего не проверяется: что лежит в базе, то и выводится.&lt;/p&gt;

&lt;p&gt;Запись на курс дальше будет называться &lt;strong&gt;объектом предметной области&lt;/strong&gt;. Предметная область - то дело, которое обслуживает приложение; здесь это обучение. Объект предметной области - понятие из этого дела, у которого есть собственные правила. У записи они есть: лимит в три курса и запрет отменять пройденное.&lt;/p&gt;

&lt;p&gt;Начнём с классов, которые описывают данные платформы. В проекте на Spring их обычно пишут с аннотациями JPA. JPA - стандарт Java для работы с базой данных через обычные объекты: класс помечают аннотациями, и библиотека сама превращает его объекты в строки таблицы и обратно. Такой класс называют &lt;strong&gt;сущностью&lt;/strong&gt;. Вот сущности платформы:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
@Entity
@Table(name = "course_participation")
public class CourseParticipation {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id", nullable = false)
    private User user;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "course_run_id", nullable = false)
    private CourseRun courseRun;

    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private ParticipationStatus status;

    @Column(name = "enrolled_at", nullable = false)
    private Instant enrolledAt;

    public CourseParticipation() { }   // конструктор без параметров нужен JPA

    // геттеры и сеттеры на все поля опущены
}

@Entity
@Table(name = "course_run")
public class CourseRun {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "program_id", nullable = false)
    private Program program;

    @Column(name = "starts_on", nullable = false)
    private LocalDate startsOn;

    protected CourseRun() { }
    // геттеры и сеттеры опущены
}

@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String email;

    protected User() { }
    // геттеры и сеттеры опущены
}

@Entity
@Table(name = "program")
public class Program {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String title;

    protected Program() { }
    // геттеры и сеттеры опущены
}

public enum ParticipationStatus { ACTIVE, CANCELLED, COMPLETED }
&lt;/pre&gt;

&lt;p&gt;Аннотации здесь делают следующее. &lt;code&gt;@Entity&lt;/code&gt; объявляет класс сущностью, &lt;code&gt;@Table&lt;/code&gt; называет таблицу, в строках которой лежат его объекты. &lt;code&gt;@Id&lt;/code&gt; помечает поле-идентификатор, а &lt;code&gt;@GeneratedValue&lt;/code&gt; говорит, что значение идентификатора назначит сама база при вставке строки. &lt;code&gt;@Column&lt;/code&gt; задаёт имя колонки, если оно отличается от имени поля, и запрещает пустое значение (&lt;code&gt;nullable = false&lt;/code&gt;). &lt;code&gt;@ManyToOne&lt;/code&gt; вместе с &lt;code&gt;@JoinColumn&lt;/code&gt; описывают связь: у многих записей может быть один и тот же пользователь и один и тот же запуск курса, а в таблице каждая такая связь хранится колонкой с идентификатором: &lt;code&gt;user_id&lt;/code&gt; для пользователя и &lt;code&gt;course_run_id&lt;/code&gt; для запуска. Параметр &lt;code&gt;fetch = FetchType.LAZY&lt;/code&gt; просит не читать связанный объект из базы, пока к нему не обратятся. &lt;code&gt;@Enumerated(EnumType.STRING)&lt;/code&gt; сохраняет состояние записи словом (&lt;code&gt;ACTIVE&lt;/code&gt;, &lt;code&gt;CANCELLED&lt;/code&gt;, &lt;code&gt;COMPLETED&lt;/code&gt;), а не порядковым номером.&lt;/p&gt;

&lt;p&gt;Всё, что аннотации сообщают о таблице, - её имя, имена колонок, связи, способ хранить состояние и получать идентификатор, - дальше в статье называется &lt;strong&gt;разметкой таблицы&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Остальное в этих классах продиктовано тем, как JPA создаёт объекты. Сначала библиотека вызывает конструктор без параметров и получает пустой объект, потом записывает в его поля значения из строки таблицы. Поэтому конструктор без параметров обязателен, а поля не могут быть объявлены &lt;code&gt;final&lt;/code&gt;. У &lt;code&gt;CourseParticipation&lt;/code&gt; этот конструктор открытый (&lt;code&gt;public&lt;/code&gt;), потому что новые записи создаёт ещё и код приложения; остальным сущностям хватает &lt;code&gt;protected&lt;/code&gt;: JPA этого достаточно. Сеттеры - методы, меняющие значение поля, - самой JPA здесь не нужны: аннотации стоят на полях, и JPA читает и записывает поля напрямую. Нужны они коду приложения, который заполняет новую запись по частям.&lt;/p&gt;

&lt;p&gt;Теперь код, который работает с этими классами. В проекте на Spring он обычно выглядит так:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
public interface CourseParticipationRepository
        extends JpaRepository&amp;lt;CourseParticipation, Long&amp;gt; {

    @Query("select p from CourseParticipation p "
         + " join fetch p.courseRun r "
         + " join fetch r.program "
         + " where p.user.id = :userId")
    List&amp;lt;CourseParticipation&amp;gt; findAllForUser(@Param("userId") Long userId);
}

public interface CourseRunRepository extends JpaRepository&amp;lt;CourseRun, Long&amp;gt; {
}

public interface UserRepository extends JpaRepository&amp;lt;User, Long&amp;gt; {
}
&lt;/pre&gt;

&lt;pre class="brush:java;"&gt;
@Service
public class ParticipationService {

    private final CourseParticipationRepository participations;
    private final CourseRunRepository courseRuns;
    private final UserRepository users;

    public ParticipationService(CourseParticipationRepository participations,
                                CourseRunRepository courseRuns,
                                UserRepository users) {
        this.participations = participations;
        this.courseRuns = courseRuns;
        this.users = users;
    }

    @Transactional
    public CourseParticipation enroll(Long userId, Long courseRunId) {
        List&amp;lt;CourseParticipation&amp;gt; all = participations.findAllForUser(userId);

        long active = all.stream()
            .filter(p -&amp;gt; p.getStatus() == ParticipationStatus.ACTIVE)
            .count();

        if (active &amp;gt;= 3) {
            throw new IllegalStateException("Слишком много активных курсов");
        }

        CourseParticipation participation = new CourseParticipation();
        participation.setUser(users.getReferenceById(userId));
        participation.setCourseRun(courseRuns.getReferenceById(courseRunId));
        participation.setStatus(ParticipationStatus.ACTIVE);
        participation.setEnrolledAt(Instant.now());

        return participations.save(participation);
    }
}
&lt;/pre&gt;

&lt;p&gt;&lt;code&gt;JpaRepository&lt;/code&gt; - интерфейс из Spring Data. Достаточно объявить его наследника и указать в угловых скобках класс сущности и тип её идентификатора - и реализацию писать не нужно: Spring Data создаст её при запуске приложения. Такие интерфейсы хранилища в Spring называют &lt;strong&gt;репозиториями&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Созданные реализации Spring сам передаёт в конструктор &lt;code&gt;ParticipationService&lt;/code&gt;: сервис их не создаёт, а получает готовыми. Это называется внедрением зависимостей, и аннотация &lt;code&gt;@Service&lt;/code&gt; как раз сообщает Spring, что объект этого класса нужно создать при запуске и передать ему всё, что перечислено в конструкторе. Название похоже на инверсию зависимостей, но речь о другом. Внедрение отвечает на вопрос, кто создаёт объект и передаёт его тому, кто им пользуется. Инверсия - на вопрос, чьё имя записано в чьём коде.&lt;/p&gt;

&lt;p&gt;Аннотация &lt;code&gt;@Query&lt;/code&gt; содержит запрос, который Spring Data выполнит при вызове метода. Запрос написан на JPQL - языке запросов JPA. Он похож на SQL, но обращается не к таблицам и колонкам, а к классам и их полям, поэтому в нём стоят &lt;code&gt;CourseParticipation&lt;/code&gt; и &lt;code&gt;p.user.id&lt;/code&gt;. &lt;code&gt;@Param("userId")&lt;/code&gt; связывает параметр метода с именем &lt;code&gt;:userId&lt;/code&gt; внутри запроса.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;join fetch&lt;/code&gt; просит прочитать связанные записи - запуск курса и его программу - тем же запросом. Без этого связи с пометкой &lt;code&gt;LAZY&lt;/code&gt; читались бы по одной, в момент обращения: список из двадцати записей дал бы один запрос за сам список и ещё по запросу на каждый запуск и каждую программу. Чтение связей по требованию называют ленивой загрузкой, а лавину мелких запросов, которую она порождает, - проблемой N+1: один запрос за список и N дополнительных.&lt;/p&gt;

&lt;p&gt;Метод &lt;code&gt;findAllForUser&lt;/code&gt; обслуживает обе задачи платформы сразу. Сервис записи берёт из него записи пользователя, чтобы посчитать активные, а экран «мои курсы» - чтобы показать список с названиями программ. Поэтому в запросе подтягивается и программа, хотя правилу про три курса она не нужна.&lt;/p&gt;

&lt;p&gt;Аннотация &lt;code&gt;@Transactional&lt;/code&gt; означает «выполни метод внутри одной транзакции». Транзакция - группа изменений в базе, которая применяется целиком или не применяется вовсе: если метод упадёт посередине, ни одно его изменение в базу не попадёт.&lt;/p&gt;

&lt;p&gt;Наконец, &lt;code&gt;getReferenceById&lt;/code&gt; возвращает объект-ссылку по идентификатору, не читая строку из базы. Новой записи на курс нужно знать только, какой пользователь и на какой запуск записан; содержимое этих объектов ей не нужно. Ради двух таких ссылок в сервис внедрены ещё два репозитория: &lt;code&gt;UserRepository&lt;/code&gt; и &lt;code&gt;CourseRunRepository&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Осталось сказать, как этот код разложен по проекту. В привычном варианте это обычно один модуль сборки, а классы разнесены по пакетам. Пакет - группа классов с общим началом полного имени, например &lt;code&gt;com.example.courses.service&lt;/code&gt;; в Java он совпадает с папкой. Все пакеты ниже лежат внутри &lt;code&gt;com.example.courses&lt;/code&gt;:&lt;/p&gt;

&lt;pre class="brush:plain;"&gt;
пакет         что внутри                                 от каких пакетов зависит
model         сущности с @Entity, ParticipationStatus    ни от каких
repository    интерфейсы Spring Data                     model
service       ParticipationService с правилами           model, repository
web           контроллеры                                service, model
&lt;/pre&gt;

&lt;p&gt;В последнем столбце перечислены только пакеты этого же проекта. От библиотек они зависят каждый по-своему: &lt;code&gt;model&lt;/code&gt; - от JPA, &lt;code&gt;repository&lt;/code&gt; - от Spring Data.&lt;/p&gt;

&lt;p&gt;Главное в этой раскладке - третья строка. Пакет с правилами (&lt;code&gt;service&lt;/code&gt;) зависит от пакета с репозиториями (&lt;code&gt;repository&lt;/code&gt;): стрелка идёт от правил к хранению, так же как в первом листинге введения, до инверсии. А через &lt;code&gt;model&lt;/code&gt; правила зависят ещё и от разметки таблиц. Следить за тем, кто от кого зависит, здесь некому: модуль один, и все открытые классы видны друг другу.&lt;/p&gt;

&lt;p&gt;Этот код работает: собирается, запускается и выполняет требования задачи. Менять его мы будем не потому, что он неправильный, а потому, что у него есть четыре следствия, которые проявляются по мере роста проекта. Их и разберём.&lt;/p&gt;

&lt;h2&gt;Привычный вариант&lt;/h2&gt;

&lt;p&gt;Прежде чем разбирать следствия, перечислим, что этот вариант даёт. Без этого не видно, от чего придётся отказываться, если его менять.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Готовые операции.&lt;/strong&gt; В &lt;code&gt;CourseParticipationRepository&lt;/code&gt; объявлен один метод - &lt;code&gt;findAllForUser&lt;/code&gt;. Остальные интерфейс получил по наследству от &lt;code&gt;JpaRepository&lt;/code&gt;, и сервис может вызывать их сразу, не написав ни строки реализации:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
participations.save(participation);
participations.findById(id);
participations.existsById(id);
participations.count();
participations.deleteById(id);
&lt;/pre&gt;

&lt;p&gt;Здесь пять из них: сохранить запись, найти её по идентификатору, проверить наличие записи с таким идентификатором, посчитать строки в таблице и удалить запись. Кроме них есть выдача по страницам и с сортировкой, поиск по образцу, удаление пачкой и другие. Если сложить объявления по документации Spring Data, получится так: двенадцать у самого &lt;code&gt;JpaRepository&lt;/code&gt;, двенадцать он наследует от &lt;code&gt;CrudRepository&lt;/code&gt;, два - от &lt;code&gt;PagingAndSortingRepository&lt;/code&gt;, семь - от &lt;code&gt;QueryByExampleExecutor&lt;/code&gt;. Чуть больше тридцати объявлений, три из них помечены как устаревшие. А запрос, которого среди готовых нет, добавляется одним методом с аннотацией &lt;code&gt;@Query&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Один класс вместо двух.&lt;/strong&gt; &lt;code&gt;CourseParticipation&lt;/code&gt; описывает строку таблицы и одновременно служит объектом, с которым работает сервис. Второй класс с теми же полями не нужен, и не нужен код, который копировал бы значения полей из одного класса в другой.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Знакомое устройство.&lt;/strong&gt; В проектах на Spring такой код встречается чаще других, его же показывают в документации и учебных примерах. Новый человек в команде, скорее всего, разберётся в нём без объяснений.&lt;/p&gt;

&lt;p&gt;Это настоящие преимущества, и отказываться от них без причины незачем. Посмотрим теперь, что приходит вместе с ними.&lt;/p&gt;

&lt;h3&gt;Четыре следствия&lt;/h3&gt;

&lt;p&gt;Разберём их по одному.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Первое: сервис зависит от разметки таблицы.&lt;/strong&gt; Сервис создаёт объекты &lt;code&gt;CourseParticipation&lt;/code&gt; и читает их поля, а этот класс описывает таблицу. Поэтому изменения в способе хранения доходят до сервиса, даже если правила не менялись. Пример: решили хранить пользователя в записи не связью &lt;code&gt;User user&lt;/code&gt;, а простым числом &lt;code&gt;Long userId&lt;/code&gt;. Поменяется сущность - и вместе с ней строка &lt;code&gt;participation.setUser(users.getReferenceById(userId))&lt;/code&gt; в сервисе, то есть в файле, где записано правило про три курса. Само правило при этом останется прежним.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Второе: вместе с нужными операциями сервис получил все остальные.&lt;/strong&gt; Для записи на курс сервису нужны две операции: прочитать записи пользователя и сохранить новую. Получил он, кроме них, &lt;code&gt;deleteAll&lt;/code&gt; (удалить все записи в таблице), &lt;code&gt;deleteAllInBatch&lt;/code&gt; (то же одним запросом), &lt;code&gt;findAll&lt;/code&gt; (прочитать всю таблицу целиком) и ещё почти три десятка. Код, которому внедрён этот репозиторий, может вызвать любую из этих операций, и ни компилятор, ни тесты не спросят зачем. А репозиториев в сервисе три, и у каждого свой полный набор.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Третье: правило проверяется только через заглушку.&lt;/strong&gt; Само правило - простая арифметика: посчитать активные записи и сравнить с тремя. Но записи сервис берёт из репозитория, а репозиторий ходит в базу. Поднимать базу ради проверки арифметики не хочется, поэтому в тесте вместо репозитория подставляют &lt;strong&gt;заглушку&lt;/strong&gt; - объект, который выдаёт себя за репозиторий и возвращает заранее заготовленный список. Способ рабочий, но у него есть слабое место, и ему посвящён следующий подраздел.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Четвёртое: правило записано в сервисе.&lt;/strong&gt; Проверка &lt;code&gt;active &amp;gt;= 3&lt;/code&gt; стоит внутри метода &lt;code&gt;enroll&lt;/code&gt;. Пока путь записи на курс один, это незаметно. Появится второй путь (перенос с одного запуска на другой, запись администратором, загрузка списка сотрудников из файла) - и проверку придётся повторить там. Повторить или забыть. С запретом отменять пройденный курс то же самое. В коде выше его ещё нет, но и записать его, кроме сервиса, некуда: у сущности открыт сеттер &lt;code&gt;setStatus&lt;/code&gt;, и перевести запись в отменённое состояние может любой код, минуя проверку.&lt;/p&gt;

&lt;p&gt;У четырёх следствий есть общее: ни одно не следует из задачи. Правило «не больше трёх активных курсов» ничего не знает ни про колонки, ни про удаление пачкой, ни про устройство таблицы - оно считает записи. Следствия появились из того, как устроен код.&lt;/p&gt;

&lt;h3&gt;Разве моки не решают задачу?&lt;/h3&gt;

&lt;p&gt;Здесь уместно возражение. Заглушку не обязательно писать руками: в Java для этого есть библиотека Mockito. Заглушку, собранную библиотекой, называют &lt;strong&gt;моком&lt;/strong&gt;. Класс для мока не пишут, а говорят библиотеке: «на такой вызов верни вот это». Базы мок не требует. Так в чём же слабое место?&lt;/p&gt;

&lt;p&gt;Вот рабочий тест привычного варианта:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
@ExtendWith(MockitoExtension.class)
class ParticipationServiceTest {

    @Mock CourseParticipationRepository participations;
    @Mock CourseRunRepository courseRuns;
    @Mock UserRepository users;

    @Test
    void не_даёт_записаться_на_четвёртый_курс() {
        when(participations.findAllForUser(1L))
            .thenReturn(List.of(active(), active(), active()));

        ParticipationService service =
            new ParticipationService(participations, courseRuns, users);

        assertThrows(IllegalStateException.class, () -&amp;gt; service.enroll(1L, 400L));
    }

    private CourseParticipation active() {
        CourseParticipation p = new CourseParticipation();
        p.setStatus(ParticipationStatus.ACTIVE);
        return p;
    }
}
&lt;/pre&gt;

&lt;p&gt;Тест выполняется за миллисекунды, базы не требует и проверяет правило про три курса. С этой стороны к нему претензий нет.&lt;/p&gt;

&lt;p&gt;Посмотрим внимательнее, что именно он проверил. Не «правило работает», а «если репозиторий вернёт три активные записи, сервис откажет в четвёртой». Первая половина фразы - предположение автора теста о том, что вернёт настоящий запрос. Сам запрос в тесте не выполняется, и предположение остаётся непроверенным.&lt;/p&gt;

&lt;p&gt;Похоже на придирку. Проверим, во что она обходится на практике.&lt;/p&gt;

&lt;p&gt;Вспомним, как устроен сервис: запрос возвращает все записи пользователя, а активные среди них отбирает сам сервис строкой &lt;code&gt;.filter(p -&amp;gt; p.getStatus() == ParticipationStatus.ACTIVE)&lt;/code&gt;. Сломаем сервис: удалим эту строку. Теперь он считает все записи подряд, включая отменённые, и будет отказывать тем, кому отказывать нельзя. Прогоним исправный и сломанный сервисы через две разные заглушки:&lt;/p&gt;

&lt;table&gt;
	&lt;thead&gt;
		&lt;tr&gt;
			&lt;th&gt;Что отдаёт заглушка&lt;/th&gt;
			&lt;th&gt;Активных записей&lt;/th&gt;
			&lt;th&gt;Правильный ответ&lt;/th&gt;
			&lt;th&gt;Сервис с фильтром&lt;/th&gt;
			&lt;th&gt;Сервис без фильтра&lt;/th&gt;
		&lt;/tr&gt;
	&lt;/thead&gt;
	&lt;tbody&gt;
		&lt;tr&gt;
			&lt;td&gt;три активные записи&lt;/td&gt;
			&lt;td&gt;три&lt;/td&gt;
			&lt;td&gt;отказать&lt;/td&gt;
			&lt;td&gt;отказал&lt;/td&gt;
			&lt;td&gt;отказал&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr&gt;
			&lt;td&gt;две активные и две отменённые&lt;/td&gt;
			&lt;td&gt;две&lt;/td&gt;
			&lt;td&gt;записать&lt;/td&gt;
			&lt;td&gt;записал&lt;/td&gt;
			&lt;td&gt;отказал&lt;/td&gt;
		&lt;/tr&gt;
	&lt;/tbody&gt;
&lt;/table&gt;

&lt;p&gt;Первая строка - тот самый тест. На исправном и на сломанном коде он ведёт себя одинаково, то есть поломки не замечает. Увидеть её можно только во второй строке, и только если автор теста догадался положить в заглушку отменённые записи.&lt;/p&gt;

&lt;p&gt;Дело не в Mockito. Заглушка, собранная любым способом, описывает представление автора теста о том, что вернёт запрос, и это представление ничем не проверяется. Таких представлений в проекте столько же, сколько тестов правила: каждый тест молча, составом заглушки, отвечает на вопрос «какие записи отдаст база». Ответы могут расходиться и между собой, и с настоящим запросом - и ни один тест об этом не сообщит.&lt;/p&gt;

&lt;p&gt;Можно, конечно, дописать тест со второй строки таблицы, и эту поломку он поймает. Но поймает потому, что автор её предугадал: тест стал ещё одним предположением о запросе, просто более удачным.&lt;/p&gt;

&lt;p&gt;Надёжнее другое. Если перенести отбор активных записей из сервиса в сам запрос к базе, у вопроса «правильно ли отбираются активные записи» появится одно место, где на него отвечают: тест, который выполняет запрос на настоящей базе. Тестам правила этот вопрос станет не нужен: они получают уже отобранные записи и проверяют только арифметику. Именно так будет сделано в следующих вариантах.&lt;/p&gt;

&lt;p&gt;Есть ещё два отличия мока от собственной реализации хранилища, помельче. Мок подменяет интерфейс Spring Data, а тот возвращает сущности, поэтому тест правила собирает объекты-сущности и ломается, когда меняются объявления методов репозитория. И мок настраивается заново в каждом тесте, тогда как собственный интерфейс хранилища позволяет написать одну реализацию для всех тестов сразу; как она выглядит, показано в разделе о варианте с отдельной моделью.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Для специалистов с опытом:&lt;/strong&gt; тест на настоящей базе в Spring обычно пишут с аннотацией &lt;code&gt;@DataJpaTest&lt;/code&gt;. Она поднимает только слой хранения (репозитории и сущности), поэтому сервис в такой тест добавляют явно, аннотацией &lt;code&gt;@Import&lt;/code&gt;. Выполняется такой тест секунды, а не миллисекунды, зато проверяет то, чего не видят ни мок, ни реализация в памяти: сам запрос, соответствие сущностей схеме таблиц, перенос значений из строк в объекты. Отвечает он на свой вопрос («отдаёт ли база правилу те записи, которых оно ждёт»), а не на вопрос «верно ли правило».&lt;/p&gt;

&lt;h2&gt;Вариант с отдельной моделью&lt;/h2&gt;

&lt;p&gt;В этом варианте правила записи на курс не знают, как устроено хранение. У них свой интерфейс к хранилищу и свои классы данных, в которых нет ни одной аннотации JPA и ни одного упоминания Spring. Классы с &lt;code&gt;@Entity&lt;/code&gt; никуда не исчезают, но переезжают в код, который отвечает за базу. Название варианта говорит о главном отличии от двух других: у правил своя модель, у таблиц своя.&lt;/p&gt;

&lt;p&gt;Чтобы граница между ними держалась сама, разложим код по четырём модулям сборки. Модуль сборки - это подпроект Maven: отдельная папка со своим файлом &lt;code&gt;pom.xml&lt;/code&gt;, где перечислено, от каких библиотек и каких других модулей он зависит. Maven - распространённая система сборки для Java: она скачивает библиотеки, компилирует код и упаковывает результат. Обязательно ли делить код именно на модули сборки - вопрос отдельный; он разобран в разделе «Уровни строгости». Та же раскладка подойдёт и для переходного варианта, о котором речь пойдёт позже.&lt;/p&gt;

&lt;pre class="brush:plain;"&gt;
модуль                что внутри                        от каких модулей зависит
courses-domain        правила и интерфейс к хранилищу   ни от каких
courses-application   сценарии, транзакции              courses-domain
courses-persistence   сущности, Spring Data             courses-domain
courses-app           запуск приложения, веб-слой       от всех трёх
&lt;/pre&gt;

&lt;p&gt;В последнем столбце перечислены только модули этого же проекта; внешние библиотеки у каждого модуля свои.&lt;/p&gt;

&lt;p&gt;У модулей есть короткие названия, которые дальше встречаются постоянно.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Домен&lt;/strong&gt; (от английского domain - «предметная область») - модуль &lt;code&gt;courses-domain&lt;/code&gt;. В нём сама задача без способов её выполнения: класс записи на курс с правилами, которые касаются одной записи (например, с запретом отменять пройденный курс), и интерфейс, через который правила обращаются к хранилищу.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Сценарии&lt;/strong&gt; - модуль &lt;code&gt;courses-application&lt;/code&gt;. Сценарий - класс, который выполняет одно действие пользователя от начала до конца: получает просьбу «записать пользователя 1 на запуск 400», достаёт нужные данные, применяет правила и сохраняет результат. В привычном варианте эту работу делал &lt;code&gt;ParticipationService&lt;/code&gt;, здесь её выполняет класс &lt;code&gt;EnrollUser&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Инфраструктура&lt;/strong&gt; - модуль &lt;code&gt;courses-persistence&lt;/code&gt;: классы с &lt;code&gt;@Entity&lt;/code&gt;, интерфейсы Spring Data и всё остальное, что умеет работать с базой.&lt;/p&gt;

&lt;p&gt;Четвёртый модуль, &lt;code&gt;courses-app&lt;/code&gt;, собирает приложение из трёх остальных и запускает его. В нём же лежит веб-слой - код, который принимает запросы из браузера и отправляет ответы.&lt;/p&gt;

&lt;p&gt;Главное в этой раскладке - первая строка таблицы. В &lt;code&gt;pom.xml&lt;/code&gt; доменного модуля нет ни Spring, ни JPA, ни драйвера базы данных. Поэтому написать в доменном коде &lt;code&gt;@Entity&lt;/code&gt; невозможно даже случайно: компилятор не найдёт такую аннотацию. Направление зависимостей здесь держит файл сборки, а не договорённость в команде.&lt;/p&gt;

&lt;h3&gt;Доменный объект&lt;/h3&gt;

&lt;p&gt;Начнём с класса, с которым работают правила. Это &lt;code&gt;CourseParticipation&lt;/code&gt; из доменного модуля - та же запись пользователя на запуск курса, только без единой аннотации. &lt;strong&gt;Доменным объектом&lt;/strong&gt; дальше называется именно такой класс: объект предметной области, записанный кодом, который ничего не знает о хранении.&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
package com.example.courses.domain;

public final class CourseParticipation {

    private final ParticipationId id;
    private final UserId userId;
    private final CourseRunId courseRunId;
    private final ParticipationStatus status;
    private final Instant enrolledAt;

    private CourseParticipation(ParticipationId id, UserId userId, CourseRunId courseRunId,
                                ParticipationStatus status, Instant enrolledAt) {
        this.id = Objects.requireNonNull(id);
        this.userId = Objects.requireNonNull(userId);
        this.courseRunId = Objects.requireNonNull(courseRunId);
        this.status = Objects.requireNonNull(status);
        this.enrolledAt = Objects.requireNonNull(enrolledAt);
    }

    public static CourseParticipation enroll(UserId userId, CourseRunId courseRunId, Instant now) {
        return new CourseParticipation(ParticipationId.NEW, userId, courseRunId,
                                       ParticipationStatus.ACTIVE, now);
    }

    public CourseParticipation cancel() {
        if (status == ParticipationStatus.COMPLETED) {
            throw new IllegalStateException(
                "Нельзя отменить запись на пройденный курс: " + id.value());
        }
        return new CourseParticipation(id, userId, courseRunId,
                                       ParticipationStatus.CANCELLED, enrolledAt);
    }

    public boolean isActive() {
        return status == ParticipationStatus.ACTIVE;
    }

    // Второй способ получить объект: собрать запись, которая уже лежит
    // в базе. Вызывает его код инфраструктуры, прочитав строку таблицы.
    public static CourseParticipation restore(ParticipationId id, UserId userId,
                                              CourseRunId courseRunId,
                                              ParticipationStatus status, Instant enrolledAt) {
        return new CourseParticipation(id, userId, courseRunId, status, enrolledAt);
    }

    // Опущены: метод complete() и чтение полей - id(), userId(),
    // courseRunId(), status(), enrolledAt().
}
&lt;/pre&gt;

&lt;p&gt;Посмотрим, чем он отличается от сущности с тем же именем из привычного варианта.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Правило находится внутри.&lt;/strong&gt; Состояние записи меняется не сеттером, а методом &lt;code&gt;cancel&lt;/code&gt;, и в этом методе проверяется запрет: запись на пройденный курс отменить нельзя. Другого способа получить отменённую запись у сценариев нет, поэтому обойти запрет не выйдет, сколько бы путей отмены ни появилось в системе. Метод &lt;code&gt;restore&lt;/code&gt;, о котором речь пойдёт ниже, собирает объект в любом состоянии, но он предназначен не для сценариев. Это ответ на четвёртое следствие привычного варианта, где правило жило в сервисе. Заметим: ответ дал не интерфейс к хранилищу, а то, что у объекта появились собственные методы.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Объект не меняется после создания.&lt;/strong&gt; Все поля объявлены &lt;code&gt;final&lt;/code&gt;, сеттеров нет. Метод &lt;code&gt;cancel&lt;/code&gt; не трогает текущий объект, а возвращает новый - с другим состоянием. Такие объекты называют неизменяемыми. Их можно передавать в любой код, не опасаясь, что где-то по дороге у них поменяется поле.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Наполовину заполненный объект создать нельзя.&lt;/strong&gt; Конструктор закрыт (&lt;code&gt;private&lt;/code&gt;), а каждый его параметр проверяется вызовом &lt;code&gt;Objects.requireNonNull&lt;/code&gt;: если хоть одно значение не передано, объект не будет создан. С сущностью так не получится: JPA требует конструктор без параметров и поля без &lt;code&gt;final&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Снаружи объект создаётся только двумя статическими методами, и нужны оба.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;enroll&lt;/code&gt; создаёт &lt;strong&gt;новую&lt;/strong&gt; запись - ту, которой ещё нет в базе. Метод сам назначает ей начальное состояние «активная» и помечает, что идентификатора у неё пока нет (&lt;code&gt;ParticipationId.NEW&lt;/code&gt;): идентификатор назначит база при сохранении. Снаружи приходят только пользователь, запуск курса и текущее время.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;restore&lt;/code&gt; (от английского «восстановить») собирает объект по записи, которая &lt;strong&gt;уже лежит&lt;/strong&gt; в базе. Здесь назначать нечего: у записи есть идентификатор, состояние и дата, и метод возвращает объект ровно в том виде, в каком он хранится. Вызывает &lt;code&gt;restore&lt;/code&gt; код инфраструктуры, когда прочитал строку из таблицы и превращает её в доменный объект. Метод открытый, иначе код из другого модуля не смог бы его вызвать. Значит, технически его может вызвать и сценарий. Удерживает от этого договорённость в команде, а при желании - тест границы из раздела «Уровни строгости»: ArchUnit умеет запрещать и вызовы отдельных методов.&lt;/p&gt;

&lt;p&gt;Почему методов два, а не один открытый конструктор на пять параметров? Потому что новая запись и прочитанная из базы - разные случаи. Новой записи состояние и пустой идентификатор назначают правила. Прочитанной ничего назначать нельзя: её надо воспроизвести как есть. Будь вход один, сценарий создавал бы новую запись тем же конструктором, что и инфраструктура, и сам передавал бы ей состояние и идентификатор, а значит, мог бы в них ошибиться. С двумя методами сценарию хватает &lt;code&gt;enroll&lt;/code&gt;: начальное состояние и пустой идентификатор метод назначит сам.&lt;/p&gt;

&lt;h3&gt;Остальные классы примера&lt;/h3&gt;

&lt;p&gt;В коде доменного объекта встретились типы, которые ещё не показаны. Вот они, а заодно и остальные классы, о которых пойдёт речь дальше:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
// courses-domain
public record UserId(Long value) { }
public record CourseRunId(Long value) { }

public record ParticipationId(Long value) {
    public static final ParticipationId NEW = new ParticipationId(null);
    public boolean isNew()  { return value == null; }
    public Long required()  { return Objects.requireNonNull(value); }
}

public enum ParticipationStatus { ACTIVE, CANCELLED, COMPLETED }

// courses-application
public class TooManyActiveCoursesException extends RuntimeException { /* ... */ }

// courses-persistence - те же классы с @Entity, что в начале статьи,
// только переименованные, чтобы не путать с доменными:
@Entity class CourseParticipationEntity { /* ... */ }
@Entity class UserEntity                { /* ... */ }
@Entity class CourseRunEntity           { /* ... */ }
@Entity class ProgramEntity             { /* ... */ }
&lt;/pre&gt;

&lt;p&gt;&lt;code&gt;record&lt;/code&gt; - короткая запись неизменяемого класса в Java: конструктор, методы чтения полей и сравнение по значению компилятор создаёт сам. &lt;code&gt;UserId&lt;/code&gt;, &lt;code&gt;CourseRunId&lt;/code&gt; и &lt;code&gt;ParticipationId&lt;/code&gt; - обёртки вокруг числового идентификатора.&lt;/p&gt;

&lt;p&gt;Зачем обёртки, если внутри всё тот же &lt;code&gt;Long&lt;/code&gt;? Чтобы компилятор различал, чей это идентификатор. Метод &lt;code&gt;findActiveForUser(UserId)&lt;/code&gt; не примет идентификатор запуска курса, хотя оба - просто числа. С голым &lt;code&gt;Long&lt;/code&gt; такую путаницу поймал бы только тест, и то если бы его написали.&lt;/p&gt;

&lt;p&gt;У &lt;code&gt;ParticipationId&lt;/code&gt; есть особенность: у новой записи идентификатора ещё нет. Домен говорит об этом прямо. Константа &lt;code&gt;NEW&lt;/code&gt; означает «пока не назначен», метод &lt;code&gt;isNew()&lt;/code&gt; проверяет, назначен ли он, а &lt;code&gt;required()&lt;/code&gt; возвращает число и падает, если числа нет; он нужен там, где идентификатор обязан быть. По &lt;code&gt;isNew()&lt;/code&gt; код инфраструктуры потом решит, вставлять новую строку в таблицу или обновлять существующую.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;TooManyActiveCoursesException&lt;/code&gt; - исключение, которое сценарий бросает при попытке записаться на четвёртый курс.&lt;/p&gt;

&lt;p&gt;Сущности в инфраструктуре - те же классы с &lt;code&gt;@Entity&lt;/code&gt;, что в привычном варианте, только с приставкой &lt;code&gt;Entity&lt;/code&gt; в имени, чтобы не путать их с доменными. Их поля и связи разобраны в начале статьи; что в них добавилось, будет сказано там, где они понадобятся.&lt;/p&gt;

&lt;h3&gt;Порт&lt;/h3&gt;

&lt;p&gt;Теперь интерфейс, через который правила обращаются к хранилищу. Такой интерфейс называют &lt;strong&gt;портом&lt;/strong&gt;: код правил объявляет его для себя сам и перечисляет в нём операции, которые ему нужны от внешнего мира.&lt;/p&gt;

&lt;p&gt;Слово пришло из вычислительной техники. У компьютера есть разъём USB. Флешка, клавиатура, принтер подключаются к нему, и компьютеру не нужно знать, как каждое устройство устроено внутри: достаточно, чтобы оно подходило к разъёму. Форму разъёма задаёт компьютер, а не производитель флешки. Аналогия грубая, но направление мысли передаёт: интерфейс задаёт код правил, а хранилище к нему подключается.&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
package com.example.courses.domain;

public interface CourseParticipations {

    List&amp;lt;CourseParticipation&amp;gt; findActiveForUser(UserId userId);

    Optional&amp;lt;CourseParticipation&amp;gt; findById(ParticipationId id);

    CourseParticipation save(CourseParticipation participation);
}
&lt;/pre&gt;

&lt;p&gt;Три метода: прочитать активные записи пользователя, прочитать одну запись по идентификатору и сохранить запись. Это всё, что нужно сценариям записи на курс и отмены записи.&lt;/p&gt;

&lt;p&gt;От обычного репозитория порт отличается не столько тем, что в нём есть, сколько тем, чего в нём нет.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Нет наследования от &lt;code&gt;JpaRepository&lt;/code&gt;.&lt;/strong&gt; Иначе домен зависел бы от Spring Data и вместе с наследством получил бы обратно все три десятка операций.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Нет типов Spring Data в объявлениях методов.&lt;/strong&gt; Ни &lt;code&gt;Page&lt;/code&gt;, ни &lt;code&gt;Pageable&lt;/code&gt;, ни &lt;code&gt;Sort&lt;/code&gt;. Стоит одному из них попасть в объявление - и доменный модуль перестанет собираться без Spring Data. Если правилам понадобится выдача по страницам, домен объявит для неё свои параметры, например номер страницы и её размер обычными числами.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Нет сущностей.&lt;/strong&gt; &lt;code&gt;CourseParticipation&lt;/code&gt; в объявлениях - доменный объект из этого же модуля, а не класс с &lt;code&gt;@Entity&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Нет запросов.&lt;/strong&gt; Ни &lt;code&gt;@Query&lt;/code&gt;, ни &lt;code&gt;join fetch&lt;/code&gt;. Метод называется &lt;code&gt;findActiveForUser&lt;/code&gt; и обещает активные записи пользователя. Как их достать (одним запросом или двумя, что подтянуть сразу, по какой колонке искать), решает инфраструктура.&lt;/p&gt;

&lt;p&gt;Последний пункт важнее, чем выглядит. В привычном варианте один метод &lt;code&gt;findAllForUser&lt;/code&gt; с одним запросом обслуживает и правило про три курса, и экран «мои курсы». Допустим, кто-то решил показывать на экране только последние десять записей и ограничил ими запрос. Правило начнёт считать активные записи по неполному списку, хотя его код никто не трогал. Когда порт объявляет отдельный метод «активные записи пользователя», а запросы для экранов живут отдельно, такая правка правило не заденет. Переписать запрос порта тоже можно, не открыв ни одного файла домена: он лежит в инфраструктуре.&lt;/p&gt;

&lt;p&gt;И про имя. Интерфейс назван &lt;code&gt;CourseParticipations&lt;/code&gt; («записи на курсы»), а не &lt;code&gt;CourseParticipationRepository&lt;/code&gt;. Слово «репозиторий» в проектах на Spring закрепилось за интерфейсами Spring Data, а порт - часть домена, и имя из понятий предметной области помогает не путать два интерфейса ни в коде, ни в разговоре. Это соглашение, а не требование.&lt;/p&gt;

&lt;h3&gt;Сценарий&lt;/h3&gt;

&lt;pre class="brush:java;"&gt;
package com.example.courses.application;

@Service
public class EnrollUser {

    private static final int MAX_ACTIVE_COURSES = 3;

    private final CourseParticipations participations;
    private final Clock clock;

    public EnrollUser(CourseParticipations participations, Clock clock) {
        this.participations = participations;
        this.clock = clock;
    }

    @Transactional
    public CourseParticipation enroll(UserId userId, CourseRunId courseRunId) {
        List&amp;lt;CourseParticipation&amp;gt; active = participations.findActiveForUser(userId);

        if (active.size() &amp;gt;= MAX_ACTIVE_COURSES) {
            throw new TooManyActiveCoursesException(
                "У пользователя " + userId.value() + " уже " + active.size()
                + " активных курсов, допускается " + MAX_ACTIVE_COURSES);
        }

        CourseParticipation participation =
            CourseParticipation.enroll(userId, courseRunId, clock.instant());

        return participations.save(participation);
    }
}
&lt;/pre&gt;

&lt;p&gt;Сценарий &lt;code&gt;EnrollUser&lt;/code&gt; делает то же, что метод &lt;code&gt;enroll&lt;/code&gt; привычного сервиса. Сравним их конструкторы. Привычный сервис получал три репозитория Spring Data. &lt;code&gt;EnrollUser&lt;/code&gt; получает порт &lt;code&gt;CourseParticipations&lt;/code&gt; и часы. Он не знает, что за портом стоит база PostgreSQL, что обращения идут через Spring Data и что активные записи достаются одним запросом.&lt;/p&gt;

&lt;p&gt;Аннотации &lt;code&gt;@Service&lt;/code&gt; и &lt;code&gt;@Transactional&lt;/code&gt; на сценарии остались. Сценарии знают про Spring: Spring создаёт их при запуске и управляет транзакциями. Не знают они другого: Spring Data и сущностей.&lt;/p&gt;

&lt;p&gt;Часы (объект &lt;code&gt;Clock&lt;/code&gt; из стандартной библиотеки Java) попали в конструктор по той же причине, что и хранилище. Вызов &lt;code&gt;Instant.now()&lt;/code&gt; внутри метода берёт время у операционной системы, и подменить его в тесте нельзя: проверить, что запись создаётся с моментом «1 марта, 10:00», не получится. Через конструктор тест передаёт часы, остановленные на нужном моменте. Во второй части серии тот же приём показан на одной функции, и итог там подведён так: «Время и база данных превратились из скрытых зависимостей в явные параметры». Здесь он применён к сценарию целиком.&lt;/p&gt;

&lt;p&gt;Отбора активных записей в сценарии больше нет: он просит у порта сразу активные. Отбор переехал в запрос к базе, и проверять его будет тест запроса, как обсуждалось в разделе про моки.&lt;/p&gt;

&lt;p&gt;Заметим, где теперь живёт правило про лимит: в сценарии, а не в доменном объекте. Оно касается не одной записи, а всех активных записей пользователя сразу, и для проверки ему нужно хранилище. Запрет отменять пройденный курс, наоборот, касается одной записи и поэтому живёт в её методе &lt;code&gt;cancel&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Ещё две мелочи, к инверсии отношения не имеющие. Число 3 вынесено в константу &lt;code&gt;MAX_ACTIVE_COURSES&lt;/code&gt;, а вместо &lt;code&gt;IllegalStateException&lt;/code&gt; сценарий бросает собственное исключение с сообщением, по которому видно, сколько курсов у пользователя и сколько допускается. Правило от этого проще найти и проще понять по сообщению об ошибке.&lt;/p&gt;

&lt;h3&gt;Адаптер и маппер&lt;/h3&gt;

&lt;p&gt;Порт объявлен - кто-то должен его реализовать. Класс, который реализует порт со стороны хранения, называют &lt;strong&gt;адаптером&lt;/strong&gt;. Он переводит просьбы домена в вызовы конкретной технологии (здесь это JPA и Spring Data). В аналогии с разъёмом это переходник: с одной стороны у него разъём, которого ждёт компьютер, с другой - разъём прибора со своим устройством. Прибор здесь - JPA и Spring Data, а переходник подгоняет их под порт.&lt;/p&gt;

&lt;p&gt;Работает адаптер с сущностью &lt;code&gt;CourseParticipationEntity&lt;/code&gt;. Это тот же класс с &lt;code&gt;@Entity&lt;/code&gt;, что &lt;code&gt;CourseParticipation&lt;/code&gt; в привычном варианте, только переименованный: те же поля, связи с пользователем и запуском курса, конструктор без параметров для JPA. Добавился конструктор со всеми полями: им пользуется код инфраструктуры, когда создаёт новую сущность.&lt;/p&gt;

&lt;p&gt;В коде адаптера встретятся ещё две вещи из фреймворков. Аннотация &lt;code&gt;@Repository&lt;/code&gt; сообщает Spring, что объект этого класса нужно создать при запуске и передавать всем, кому нужен &lt;code&gt;CourseParticipations&lt;/code&gt;. &lt;code&gt;EntityManager&lt;/code&gt; - главный объект JPA: через него сущности читаются из базы, сохраняются и связываются друг с другом.&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
package com.example.courses.persistence;

@Repository
class JpaCourseParticipations implements CourseParticipations {

    private final CourseParticipationJpaRepository jpa;
    private final EntityManager entityManager;

    JpaCourseParticipations(CourseParticipationJpaRepository jpa,
                            EntityManager entityManager) {
        this.jpa = jpa;
        this.entityManager = entityManager;
    }

    @Override
    public List&amp;lt;CourseParticipation&amp;gt; findActiveForUser(UserId userId) {
        return jpa.findActiveForUser(userId.value()).stream()
            .map(CourseParticipationMapper::toDomain)
            .toList();
    }

    @Override
    public Optional&amp;lt;CourseParticipation&amp;gt; findById(ParticipationId id) {
        return jpa.findById(id.required())
            .map(CourseParticipationMapper::toDomain);
    }

    @Override
    public CourseParticipation save(CourseParticipation participation) {
        if (participation.id().isNew()) {
            UserEntity user = entityManager.getReference(
                UserEntity.class, participation.userId().value());
            CourseRunEntity courseRun = entityManager.getReference(
                CourseRunEntity.class, participation.courseRunId().value());

            CourseParticipationEntity saved = jpa.save(
                CourseParticipationMapper.toNewEntity(participation, user, courseRun));

            return CourseParticipationMapper.toDomain(saved);
        }

        CourseParticipationEntity managed = jpa.findById(participation.id().required())
            .orElseThrow(() -&amp;gt; new NoSuchElementException(
                "Запись исчезла между чтением и сохранением"));

        managed.setStatus(participation.status());

        return CourseParticipationMapper.toDomain(managed);
    }
}
&lt;/pre&gt;

&lt;p&gt;Внутри адаптер пользуется знакомым интерфейсом Spring Data, который переехал в инфраструктуру:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
package com.example.courses.persistence;

interface CourseParticipationJpaRepository
        extends JpaRepository&amp;lt;CourseParticipationEntity, Long&amp;gt; {

    @Query("select p from CourseParticipationEntity p "
         + " join fetch p.courseRun "
         + " where p.user.id = :userId "
         + "   and p.status = com.example.courses.domain.ParticipationStatus.ACTIVE")
    List&amp;lt;CourseParticipationEntity&amp;gt; findActiveForUser(@Param("userId") Long userId);
}
&lt;/pre&gt;

&lt;p&gt;Spring Data по-прежнему даёт этому интерфейсу около трёх десятков готовых операций. Изменилось то, кто их видит: интерфейс подключён только к адаптеру, сценарии его не получают.&lt;/p&gt;

&lt;p&gt;Запрос изменился в двух местах. Отбор активных записей переехал в него из сервиса (условие &lt;code&gt;p.status = ...ACTIVE&lt;/code&gt;). А &lt;code&gt;join fetch r.program&lt;/code&gt; исчез: название программы правилам не нужно, его показывает только экран «мои курсы», и для экрана будет свой запрос; он описан в разделе «Что не нужно инвертировать». Обе правки следуют из порта: запрос подстраивается под то, о чём просит домен.&lt;/p&gt;

&lt;p&gt;Адаптер и интерфейс Spring Data объявлены без слова &lt;code&gt;public&lt;/code&gt;, то есть видны только внутри своего пакета &lt;code&gt;com.example.courses.persistence&lt;/code&gt;. Код из других пакетов не может даже упомянуть их имена ни в типе переменной, ни в строке импорта. Видимость в Java ограничена пакетом, а не модулем сборки, но этот пакет целиком лежит в модуле инфраструктуры, так что снаружи модуля до них не добраться. Spring это не мешает: он создаёт объекты при запуске приложения в обход обычных правил видимости.&lt;/p&gt;

&lt;p&gt;Здесь и происходит инверсия, о которой шла речь во введении. Модуль &lt;code&gt;courses-persistence&lt;/code&gt; ссылается на &lt;code&gt;courses-domain&lt;/code&gt;: импортирует порт и доменный объект. Обратной ссылки нет, и добавить её не получится: Maven откажется собирать модули, которые ссылаются друг на друга по кругу. А вызов идёт, как и раньше, от сценария к базе.&lt;/p&gt;

&lt;p&gt;Метод &lt;code&gt;save&lt;/code&gt; стоит пояснить. Если запись новая (&lt;code&gt;id().isNew()&lt;/code&gt;), адаптер создаёт сущность и сохраняет её: &lt;code&gt;jpa.save&lt;/code&gt; вставит строку в таблицу, а база назначит идентификатор. Для связей сущности нужны пользователь и запуск курса, но читать их из базы незачем: &lt;code&gt;entityManager.getReference&lt;/code&gt; даёт ссылку по идентификатору без запроса, так же как &lt;code&gt;getReferenceById&lt;/code&gt; в привычном варианте.&lt;/p&gt;

&lt;p&gt;Если запись уже есть в базе, адаптер читает её сущность и переносит в неё новое состояние. Остальные поля переносить незачем: у доменного объекта после создания меняется только состояние. Вызова &lt;code&gt;jpa.save&lt;/code&gt; в этой ветке нет намеренно. Сущность, прочитанная внутри транзакции, считается управляемой: JPA следит за её полями и сама запишет изменения в базу, когда транзакция завершится. А транзакцию открывает сценарий: на нём стоит &lt;code&gt;@Transactional&lt;/code&gt;. Отсюда ограничение: вызванный вне транзакции, этот метод изменение потеряет. Это ещё один довод за то, чтобы транзакции начинались и заканчивались в сценариях.&lt;/p&gt;

&lt;p&gt;Остаётся класс, который превращает сущность в доменный объект и обратно. Его называют &lt;strong&gt;маппером&lt;/strong&gt; (от английского map - «сопоставлять»): он берёт значения полей одного объекта и переносит их в поля другого.&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
package com.example.courses.persistence;

final class CourseParticipationMapper {

    private CourseParticipationMapper() { }

    static CourseParticipation toDomain(CourseParticipationEntity entity) {
        return CourseParticipation.restore(
            new ParticipationId(entity.getId()),
            new UserId(entity.getUser().getId()),
            new CourseRunId(entity.getCourseRun().getId()),
            entity.getStatus(),
            entity.getEnrolledAt());
    }

    static CourseParticipationEntity toNewEntity(CourseParticipation participation,
                                                 UserEntity user,
                                                 CourseRunEntity courseRun) {
        return new CourseParticipationEntity(
            null,
            user,
            courseRun,
            participation.status(),
            participation.enrolledAt());
    }
}
&lt;/pre&gt;

&lt;p&gt;&lt;code&gt;toDomain&lt;/code&gt; вызывается, когда строку прочитали из базы: из сущности берутся её идентификатор, идентификаторы связанных пользователя и запуска курса, состояние и дата записи, и методом &lt;code&gt;restore&lt;/code&gt; из них собирается доменный объект. &lt;code&gt;toNewEntity&lt;/code&gt; работает в обратную сторону и только для новой записи: идентификатор передаётся пустым (&lt;code&gt;null&lt;/code&gt;), его назначит база.&lt;/p&gt;

&lt;p&gt;Маппер пишется руками и правится каждый раз, когда у записи появляется новое поле. Во что это обходится, разобрано в разделе «Что этот вариант даёт и чем платит».&lt;/p&gt;

&lt;p&gt;У маппера есть свойство, которое видно не сразу. Он вызывается внутри транзакции, пока соединение с базой открыто, и всё, что нужно доменному объекту, читает из сущности тут же. Наружу уходит объект, которому база больше не понадобится. В привычном варианте наружу уходила сама сущность, и если код уже после завершения транзакции обращался к её ленивой связи, он получал исключение &lt;code&gt;LazyInitializationException&lt;/code&gt;: соединения нет, дочитать связанный объект нечем. Здесь такой ошибке взяться неоткуда.&lt;/p&gt;

&lt;h3&gt;Тест, которому не нужна база&lt;/h3&gt;

&lt;p&gt;Порт - обычный интерфейс, и вторая его реализация для тестов пишется за несколько минут. Записи она держит в обычном списке:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
class InMemoryCourseParticipations implements CourseParticipations {

    private final List&amp;lt;CourseParticipation&amp;gt; storage = new ArrayList&amp;lt;&amp;gt;();
    private final AtomicLong sequence = new AtomicLong(0);

    @Override
    public List&amp;lt;CourseParticipation&amp;gt; findActiveForUser(UserId userId) {
        return storage.stream()
            .filter(p -&amp;gt; p.userId().equals(userId))
            .filter(CourseParticipation::isActive)
            .toList();
    }

    @Override
    public Optional&amp;lt;CourseParticipation&amp;gt; findById(ParticipationId id) {
        return storage.stream()
            .filter(p -&amp;gt; !p.id().isNew() &amp;amp;&amp;amp; p.id().equals(id))
            .findFirst();
    }

    @Override
    public CourseParticipation save(CourseParticipation participation) {
        ParticipationId id = participation.id().isNew()
            ? new ParticipationId(sequence.incrementAndGet())
            : participation.id();

        CourseParticipation stored = CourseParticipation.restore(
            id, participation.userId(), participation.courseRunId(),
            participation.status(), participation.enrolledAt());

        storage.removeIf(p -&amp;gt; !p.id().isNew() &amp;amp;&amp;amp; p.id().equals(id));
        storage.add(stored);
        return stored;
    }
}
&lt;/pre&gt;

&lt;p&gt;Отбор активных записей (фильтр &lt;code&gt;isActive&lt;/code&gt;) записан здесь один раз для всех тестов. Его можно прочитать, в нём можно поставить точку останова и пройти отладчиком. Это тоже заглушка, но не мок: обычный класс, а не набор ответов, который задаётся заново в каждом тесте.&lt;/p&gt;

&lt;p&gt;Фильтр &lt;code&gt;isActive&lt;/code&gt; - тоже предположение о том, что вернёт настоящий запрос. Разница в том, что предположение теперь одно на весь проект и его можно проверить. Для этого обе реализации порта (в памяти и адаптер) прогоняют через один и тот же набор проверок: сохранили активную и отменённую записи, вызвали &lt;code&gt;findActiveForUser&lt;/code&gt; - вернулась одна. Для реализации в памяти такая проверка идёт за миллисекунды, для адаптера - на настоящей базе. Если обе проходят, реализация в памяти ведёт себя так же, как настоящее хранилище, и тесты правил, построенные на ней, ничего не выдумывают.&lt;/p&gt;

&lt;p&gt;С ней проверка правила выглядит так:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
class EnrollUserTest {

    private static final Clock FIXED_CLOCK =
        Clock.fixed(Instant.parse("2026-03-01T10:00:00Z"), ZoneOffset.UTC);

    private final InMemoryCourseParticipations participations =
        new InMemoryCourseParticipations();

    private final EnrollUser enrollUser = new EnrollUser(participations, FIXED_CLOCK);

    @Test
    void не_даёт_записаться_на_четвёртый_курс() {
        UserId user = new UserId(1L);
        enrollUser.enroll(user, new CourseRunId(100L));
        enrollUser.enroll(user, new CourseRunId(200L));
        enrollUser.enroll(user, new CourseRunId(300L));

        assertThrows(TooManyActiveCoursesException.class,
            () -&amp;gt; enrollUser.enroll(user, new CourseRunId(400L)));
    }

    @Test
    void отменённая_запись_освобождает_место() {
        UserId user = new UserId(1L);
        CourseParticipation first = enrollUser.enroll(user, new CourseRunId(100L));
        enrollUser.enroll(user, new CourseRunId(200L));
        enrollUser.enroll(user, new CourseRunId(300L));

        participations.save(first.cancel());

        assertTrue(enrollUser.enroll(user, new CourseRunId(400L)).isActive());
    }
}
&lt;/pre&gt;

&lt;p&gt;Сценарий собирается обычным &lt;code&gt;new&lt;/code&gt;: ему передают хранилище в памяти и часы, остановленные на 1 марта 2026 года, 10:00. Это возможно потому, что сценарий зависит от интерфейса, а не от Spring Data. В файле теста нет ни &lt;code&gt;@SpringBootTest&lt;/code&gt;, ни &lt;code&gt;@DataJpaTest&lt;/code&gt;, ни базы, ни моков, и выполняется он за миллисекунды. Второй тест проверяет как раз то, мимо чего прошёл мок в привычном варианте: отменённая запись освобождает место.&lt;/p&gt;

&lt;p&gt;Специально для теста ничего не понадобилось: ни настройки Spring, ни библиотеки моков. Хватило того, что сценарий зависит от интерфейса, а время получает через конструктор. Во второй части серии эта связь сформулирована так: «если что-то трудно протестировать, проблема почти никогда не в тестах. Проблема в структуре». Здесь видно то же самое с обратной стороны: поправили структуру - и тест стал простым сам.&lt;/p&gt;

&lt;p&gt;Тест на настоящей базе после этого тоже нужен, но проверяет он уже не правило, а хранение: правильно ли запрос отбирает активные записи, совпадают ли сущности со схемой таблиц, верно ли маппер переносит поля, назначает ли база идентификаторы. Получается такая пропорция: быстрых тестов правил много, и они перебирают все случаи; медленных тестов хранения немного, и они проверяют, что данные действительно доходят до базы и возвращаются обратно.&lt;/p&gt;

&lt;h2&gt;Что этот вариант даёт и чем платит&lt;/h2&gt;

&lt;p&gt;Вернёмся к четырём следствиям привычного варианта и посмотрим, что стало с каждым.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Сценарий не зависит от разметки таблицы.&lt;/strong&gt; &lt;code&gt;EnrollUser&lt;/code&gt; работает с доменным объектом, а &lt;code&gt;@Entity&lt;/code&gt; остался в инфраструктуре. Если пользователя в таблице решат хранить не связью, а числом, поменяются сущность и маппер, а файл с правилом про три курса останется прежним.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Лишних операций нет.&lt;/strong&gt; Сценарию доступны три метода порта. &lt;code&gt;deleteAllInBatch&lt;/code&gt; из него не вызвать: в порту такого объявления нет.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Правило проверяется без мока.&lt;/strong&gt; Тесты сценариев работают с одной реализацией порта в памяти, а вопрос «правильно ли отбираются активные записи» проверяется отдельно, тестом запроса на настоящей базе.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Правило переехало в доменный объект.&lt;/strong&gt; Запрет отменять пройденный курс проверяется в методе &lt;code&gt;cancel&lt;/code&gt;, и ни один сценарий отмены его не обойдёт.&lt;/p&gt;

&lt;p&gt;Теперь о том, чем за это платят.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Два класса на одну запись.&lt;/strong&gt; &lt;code&gt;CourseParticipation&lt;/code&gt; и &lt;code&gt;CourseParticipationEntity&lt;/code&gt; описывают одно и то же, и новое поле придётся добавлять в оба.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Маппер.&lt;/strong&gt; На пяти полях он короткий. Но объекты бывают сложнее: со списками вложенных объектов, с полями-объектами, с датами в разных часовых поясах. Тогда маппер - заметный объём кода, который надо написать, покрыть тестами и править вместе с каждым полем. Есть библиотеки, которые создают такой код автоматически по описанию, например MapStruct, но поначалу проще написать его руками: так видно, что куда переносится.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Больше файлов.&lt;/strong&gt; В привычном варианте у записи на курс два файла: интерфейс репозитория и сущность. Здесь их шесть: доменный объект, порт, интерфейс Spring Data, адаптер, маппер и сущность. Дорога по коду тоже становится длиннее: щёлкнув в среде разработки по вызову &lt;code&gt;participations.save(...)&lt;/code&gt; в сценарии, читатель попадает в объявление порта, а не в работающий код, и реализацию ищет отдельно.&lt;/p&gt;

&lt;p&gt;Если вдобавок разносить код по модулям сборки, растёт и время сборки, но это отдельный выбор, общий для обоих вариантов с портом; он разобран в разделе «Уровни строгости».&lt;/p&gt;

&lt;p&gt;Нужно ли всё это проекту? В третьей части серии предложен ориентир: инвертировать зависимость стоит там, где можно внятно назвать второй возможный вариант реализации. У хранилища он есть почти всегда: хотя бы реализация в памяти, которую мы только что написали для теста. Но ориентир отвечает на вопрос, нужен ли порт, а не на вопрос, нужна ли отдельная модель. Порт - это один файл. Отдельная модель - второй класс и маппер на каждый объект предметной области. Бывает, что порт уже нужен, а отдельная модель пока нет. Для этого случая и существует переходный вариант.&lt;/p&gt;

&lt;h2&gt;Переходный вариант: порт без отдельной модели&lt;/h2&gt;

&lt;p&gt;Идея такая: сущность остаётся единственным классом записи на курс, а интерфейс Spring Data, вместо того чтобы внедряться в сервис, реализует порт. Порт объявлен в доменном модуле, как и в предыдущем варианте:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
// courses-domain
public interface CourseParticipations {

    CourseParticipation save(CourseParticipation participation);

    Optional&amp;lt;CourseParticipation&amp;gt; findById(Long id);

    List&amp;lt;CourseParticipation&amp;gt; findActiveForUser(Long userId);
}
&lt;/pre&gt;

&lt;p&gt;А интерфейс Spring Data в инфраструктуре наследует сразу и порт, и &lt;code&gt;JpaRepository&lt;/code&gt;:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
// courses-persistence
interface CourseParticipationJpaRepository
        extends CourseParticipations, JpaRepository&amp;lt;CourseParticipation, Long&amp;gt; {

    @Override
    @Query("select p from CourseParticipation p "
         + " join fetch p.courseRun "
         + " where p.user.id = :userId "
         + "   and p.status = com.example.courses.domain.ParticipationStatus.ACTIVE")
    List&amp;lt;CourseParticipation&amp;gt; findActiveForUser(@Param("userId") Long userId);
}
&lt;/pre&gt;

&lt;p&gt;Реализацию этого интерфейса Spring Data создаёт так же, как раньше, и она годится для порта целиком. Методы &lt;code&gt;save&lt;/code&gt; и &lt;code&gt;findById&lt;/code&gt; порта совместимы с теми, что &lt;code&gt;JpaRepository&lt;/code&gt; наследует от &lt;code&gt;CrudRepository&lt;/code&gt;, и выполняются готовым кодом Spring Data; что значит «совместимы», разобрано ниже, в подразделе о ловушке. Метод &lt;code&gt;findActiveForUser&lt;/code&gt; выполняется запросом из &lt;code&gt;@Query&lt;/code&gt;. Порт реализован, а класс-адаптер писать не пришлось.&lt;/p&gt;

&lt;p&gt;Модули те же, что в варианте с отдельной моделью, но разложено по ним другое:&lt;/p&gt;

&lt;pre class="brush:plain;"&gt;
модуль                что внутри                                  от каких модулей зависит
courses-domain        сущности с @Entity, порты                   ни от каких
courses-application   ParticipationService, транзакции            courses-domain
courses-persistence   интерфейсы Spring Data, наследующие порты   courses-domain
courses-app           запуск приложения, веб-слой                 от всех трёх
&lt;/pre&gt;

&lt;p&gt;Отличие от варианта с отдельной моделью - в первой строке. В домене лежат порты и сущности (&lt;code&gt;CourseParticipation&lt;/code&gt;, &lt;code&gt;User&lt;/code&gt;, &lt;code&gt;CourseRun&lt;/code&gt;, &lt;code&gt;Program&lt;/code&gt;) вместе с их аннотациями, поэтому из внешних библиотек домену нужна JPA (&lt;code&gt;jakarta.persistence-api&lt;/code&gt;). Направление зависимостей между модулями при этом то же: все стрелки ведут к домену, и сервис с правилами, как и прежде, не зависит от инфраструктуры. Отдельного доменного объекта нет, правила работают с сущностью, поэтому и маппер не нужен: копировать значения полей между двумя классами не приходится, класс один. Запрос тот же, что в адаптере варианта с отдельной моделью: отбор активных записей в нём есть, а программа не подтягивается, потому что правилу она не нужна.&lt;/p&gt;

&lt;p&gt;Так же поступают с двумя другими репозиториями сервиса. Пользователь и запуск курса нужны сервису только ради ссылки по идентификатору, поэтому их порты состоят из одного метода:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
// courses-domain
public interface Users {
    User getReferenceById(Long id);
}

public interface CourseRuns {
    CourseRun getReferenceById(Long id);
}

// courses-persistence
interface UserJpaRepository extends Users, JpaRepository&amp;lt;User, Long&amp;gt; { }

interface CourseRunJpaRepository extends CourseRuns, JpaRepository&amp;lt;CourseRun, Long&amp;gt; { }
&lt;/pre&gt;

&lt;p&gt;Сервис после этого выглядит так:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
@Service
public class ParticipationService {

    private final CourseParticipations participations;
    private final CourseRuns courseRuns;
    private final Users users;

    public ParticipationService(CourseParticipations participations,
                                CourseRuns courseRuns,
                                Users users) {
        this.participations = participations;
        this.courseRuns = courseRuns;
        this.users = users;
    }

    @Transactional
    public CourseParticipation enroll(Long userId, Long courseRunId) {
        List&amp;lt;CourseParticipation&amp;gt; active = participations.findActiveForUser(userId);

        if (active.size() &amp;gt;= 3) {
            throw new IllegalStateException("Слишком много активных курсов");
        }

        CourseParticipation participation = new CourseParticipation();
        participation.setUser(users.getReferenceById(userId));
        participation.setCourseRun(courseRuns.getReferenceById(courseRunId));
        participation.setStatus(ParticipationStatus.ACTIVE);
        participation.setEnrolledAt(Instant.now());

        return participations.save(participation);
    }
}
&lt;/pre&gt;

&lt;p&gt;По сравнению с привычным вариантом поменялись типы в конструкторе и исчез фильтр: активные записи теперь отбирает запрос. Остальное не тронуто. В сервисе не осталось ни одного типа Spring Data.&lt;/p&gt;

&lt;p&gt;Что этот вариант даёт. Сервис больше не видит &lt;code&gt;JpaRepository&lt;/code&gt; и его операций: ему доступны три метода одного порта и по одному методу двух других. &lt;code&gt;@Query&lt;/code&gt; переехала в инфраструктуру. Для тестов можно написать свою реализацию порта в памяти, как в предыдущем варианте, с той разницей, что хранить она будет сущности.&lt;/p&gt;

&lt;p&gt;Чего он не даёт. На классе &lt;code&gt;CourseParticipation&lt;/code&gt; по-прежнему стоит &lt;code&gt;@Entity&lt;/code&gt;, а сам класс теперь лежит в доменном модуле. Значит, в &lt;code&gt;pom.xml&lt;/code&gt; этого модуля придётся добавить библиотеку &lt;code&gt;jakarta.persistence-api&lt;/code&gt;, иначе аннотации JPA не скомпилируются. Домен без единой внешней зависимости здесь не получится: он знает разметку таблицы. И запрет отменять пройденный курс по-прежнему живёт в сервисе. Перенести его в сущность можно: добавить ей метод &lt;code&gt;cancel&lt;/code&gt; с проверкой и убрать сеттер &lt;code&gt;setStatus&lt;/code&gt;. Но тогда класс, описывающий таблицу, начинает описывать и поведение записи, и правка одного задевает другое. Это уже первый шаг к отдельной модели.&lt;/p&gt;

&lt;h3&gt;Ловушка с объявлениями методов&lt;/h3&gt;

&lt;p&gt;Приём работает не с любым портом. Если в порту есть метод с тем же именем, что у метода &lt;code&gt;CrudRepository&lt;/code&gt; (а &lt;code&gt;save&lt;/code&gt; и &lt;code&gt;findById&lt;/code&gt; там есть), объявления должны быть совместимы: те же типы параметров и подходящий тип результата. Иначе интерфейс Spring Data не скомпилируется. Например, привычное для порта объявление &lt;code&gt;void save(CourseParticipation participation)&lt;/code&gt; даёт такую ошибку:&lt;/p&gt;

&lt;pre class="brush:plain;"&gt;
error: types CrudRepository&amp;lt;CourseParticipation,Long&amp;gt; and CourseParticipations
       are incompatible;
  both define save(CourseParticipation), but with unrelated return types
&lt;/pre&gt;

&lt;p&gt;Причина в том, как &lt;code&gt;save&lt;/code&gt; объявлен в Spring Data: &lt;code&gt;&amp;lt;S extends T&amp;gt; S save(S entity)&lt;/code&gt;. В &lt;code&gt;JpaRepository&amp;lt;CourseParticipation, Long&amp;gt;&lt;/code&gt; вместо &lt;code&gt;T&lt;/code&gt; стоит &lt;code&gt;CourseParticipation&lt;/code&gt;, то есть метод принимает запись (или объект её подкласса) и возвращает объект того же типа. Сверяя интерфейсы, компилятор считает &lt;code&gt;save&lt;/code&gt; из порта и &lt;code&gt;save&lt;/code&gt; из Spring Data одним методом: параметр у них один и тот же. А у одного метода не может быть двух несовместимых типов результата: &lt;code&gt;void&lt;/code&gt; и &lt;code&gt;CourseParticipation&lt;/code&gt;. Ошибка видна сразу, при компиляции, а не при запуске приложения.&lt;/p&gt;

&lt;p&gt;Отсюда два ограничения. Сохранение в порту объявляется как &lt;code&gt;CourseParticipation save(CourseParticipation)&lt;/code&gt;, а не &lt;code&gt;void&lt;/code&gt;. А &lt;code&gt;findById&lt;/code&gt; должен принимать &lt;code&gt;Long&lt;/code&gt;: тип идентификатора у &lt;code&gt;CrudRepository&lt;/code&gt; задан вторым параметром в &lt;code&gt;JpaRepository&amp;lt;CourseParticipation, Long&amp;gt;&lt;/code&gt;, и обёртку &lt;code&gt;ParticipationId&lt;/code&gt; в этот метод не подставить.&lt;/p&gt;

&lt;p&gt;Выходит, что в переходном варианте объявления порта подогнаны под интерфейс Spring Data, а не под нужды правил. Как промежуточная ступень это работает. Как конечная точка для проекта, где правил много, - хуже: каждое новое объявление в порту приходится сверять с &lt;code&gt;CrudRepository&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Практический ориентир:&lt;/strong&gt; сверьтесь с четырьмя следствиями привычного варианта. Переходный вариант убирает два из них (лишние операции и проверку правила через мок) и попутно уносит &lt;code&gt;@Query&lt;/code&gt; в инфраструктуру. Два остаются: домен знает разметку таблицы, а запрет отменять пройденный курс живёт в сервисе. Если эти два вам сейчас не мешают, на переходном варианте можно остановиться.&lt;/p&gt;

&lt;h2&gt;Три варианта рядом&lt;/h2&gt;

&lt;p&gt;Сведём различия в одно место.&lt;/p&gt;

&lt;p style="text-align:center;"&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/12054155/pr-1-tri-varianta.png/8ec6ba18-eb9b-e267-0bf5-beb3a6a8ce9c?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p style="text-align:center;"&gt;&amp;nbsp;&lt;/p&gt;

&lt;p style="text-align:center;"&gt;&lt;em&gt;Рисунок 1. Что код правил знает о хранении; на рисунке он подписан именем доменного модуля &lt;code&gt;courses-domain&lt;/code&gt;. В привычном варианте - и Spring Data, и разметку таблицы. В переходном Spring Data уходит, а &lt;code&gt;@Entity&lt;/code&gt; остаётся. В варианте с отдельной моделью уходит и &lt;code&gt;@Entity&lt;/code&gt;, зато появляется маппер. Вызов во всех трёх вариантах идёт одинаково: из правил в базу.&lt;/em&gt;&lt;/p&gt;

&lt;table&gt;
	&lt;thead&gt;
		&lt;tr&gt;
			&lt;th&gt;&amp;nbsp;&lt;/th&gt;
			&lt;th&gt;Привычный&lt;/th&gt;
			&lt;th&gt;Переходный&lt;/th&gt;
			&lt;th&gt;С отдельной моделью&lt;/th&gt;
		&lt;/tr&gt;
	&lt;/thead&gt;
	&lt;tbody&gt;
		&lt;tr&gt;
			&lt;td&gt;Код правил знает про Spring Data&lt;/td&gt;
			&lt;td&gt;да&lt;/td&gt;
			&lt;td&gt;нет&lt;/td&gt;
			&lt;td&gt;нет&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr&gt;
			&lt;td&gt;Код правил знает разметку таблицы&lt;/td&gt;
			&lt;td&gt;да&lt;/td&gt;
			&lt;td&gt;да&lt;/td&gt;
			&lt;td&gt;нет&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr&gt;
			&lt;td&gt;Операций хранилища доступно коду записи на курс&lt;/td&gt;
			&lt;td&gt;около тридцати в каждом из трёх репозиториев&lt;/td&gt;
			&lt;td&gt;пять в трёх портах&lt;/td&gt;
			&lt;td&gt;три в одном порту&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr&gt;
			&lt;td&gt;Где лежит &lt;code&gt;@Query&lt;/code&gt;&lt;/td&gt;
			&lt;td&gt;в интерфейсе, который видит сервис&lt;/td&gt;
			&lt;td&gt;в инфраструктуре&lt;/td&gt;
			&lt;td&gt;в инфраструктуре&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr&gt;
			&lt;td&gt;Чем заменяют хранилище в тесте правила&lt;/td&gt;
			&lt;td&gt;мок&lt;/td&gt;
			&lt;td&gt;своя реализация порта&lt;/td&gt;
			&lt;td&gt;своя реализация порта&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr&gt;
			&lt;td&gt;Где записан запрет отменять пройденный курс&lt;/td&gt;
			&lt;td&gt;в сервисе&lt;/td&gt;
			&lt;td&gt;в сервисе&lt;/td&gt;
			&lt;td&gt;в доменном объекте&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr&gt;
			&lt;td&gt;Файлов на объект «запись на курс»&lt;/td&gt;
			&lt;td&gt;два&lt;/td&gt;
			&lt;td&gt;три&lt;/td&gt;
			&lt;td&gt;шесть&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr&gt;
			&lt;td&gt;Маппер&lt;/td&gt;
			&lt;td&gt;нет&lt;/td&gt;
			&lt;td&gt;нет&lt;/td&gt;
			&lt;td&gt;есть&lt;/td&gt;
		&lt;/tr&gt;
	&lt;/tbody&gt;
&lt;/table&gt;

&lt;p&gt;Последние две строки - то, чем платят: сколько кода придётся написать и потом поддерживать. Первые шесть - то, что за это получают.&lt;/p&gt;

&lt;h3&gt;Зачем уходить от привычного варианта&lt;/h3&gt;

&lt;p&gt;Таблица показывает различия, но не отвечает на вопрос, который задаст тот, у кого код уже работает: что изменится в ежедневной работе после переделки? Изменятся четыре вещи, и все они касаются того, что разработчик делает с правилами каждый день: читает их, меняет и проверяет. Третья из них появляется уже в переходном варианте, остальные - только при отдельной модели.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Правило можно прочитать, не зная схемы базы.&lt;/strong&gt; Новый человек открывает &lt;code&gt;EnrollUser&lt;/code&gt; и видит: если активных записей три или больше - отказать. Ни таблиц, ни колонок, ни &lt;code&gt;join fetch&lt;/code&gt;. Чтобы понять правило, его достаточно прочитать, а чтобы поменять, не нужно разбираться, как устроено хранение.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Изменение схемы не доходит до правил.&lt;/strong&gt; Переименовали колонку, разбили таблицу на две, заменили связь числом - правятся сущность и маппер. Файл с правилом при этом не меняется, и перепроверять его перед выпуском новой версии незачем.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Тесты правил быстрые и не опираются на догадки.&lt;/strong&gt; Они не поднимают базу и не содержат предположений о том, что вернёт запрос: проверка запроса вынесена в отдельный тест на настоящей базе.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Каждое правило записано в одном месте.&lt;/strong&gt; Запрет отменять пройденный курс живёт в методе &lt;code&gt;cancel&lt;/code&gt;. Сколько бы путей отмены ни появилось, проверка у них общая, и забыть её в новом пути не получится: другого способа отменить запись у сценариев нет.&lt;/p&gt;

&lt;p&gt;Полная переделка (до отдельной модели) стоит своих шести файлов на объект тогда, когда правил в системе становится столько, что их чтение, изменение и проверка занимают заметную часть работы команды. Если правил почти нет и код в основном переносит данные из формы в таблицу и обратно, эти четыре изменения ничего не облегчают: читать, менять и проверять почти нечего.&lt;/p&gt;

&lt;h3&gt;Как выбрать вариант для нового проекта&lt;/h3&gt;

&lt;p&gt;Размер проекта и число разработчиков здесь подсказывают мало. Важнее, какого кода в проекте будет больше, а код бывает двух видов.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Код, который переносит данные.&lt;/strong&gt; Пришёл запрос - прочитали строки из таблицы - показали на экране. Или наоборот: пришла заполненная форма - разложили значения по колонкам - сохранили. Между «пришло» и «сохранили» такой код ничего не решает: не сравнивает, не проверяет условий, не отказывает. Экран «мои курсы» из нашего примера - как раз такой код.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Код, который принимает решения.&lt;/strong&gt; Прежде чем что-то сделать, он проверяет условия и может отказать или выбрать один из путей. Запись на курс - такой код: прежде чем вставить строку, надо посчитать активные записи пользователя и при трёх отказать. Условие задано не программистом и не базой: его установили те, кто отвечает за продукт.&lt;/p&gt;

&lt;p&gt;Прикиньте, какого кода в вашем проекте будет больше. От этого и зависит выбор.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Привычный вариант - когда решений почти нет.&lt;/strong&gt; Справочник городов, панель администратора для правки записей, внутренний отчёт, прототип, который выбросят через месяц. Порт и отдельная модель отделяют правила от хранения, а правил здесь нет. Каждый объект обошёлся бы в четыре лишних файла (порт, адаптер, доменный класс и маппер), и ни один из них не упростил бы ни чтение, ни изменение, ни проверку кода, который просто переносит поля.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Переходный вариант - когда правила есть, но их немного.&lt;/strong&gt; Например, интернет-магазин небольшой компании. Правил там несколько: нельзя заказать товар, которого нет на складе; скидка положена при сумме заказа от пяти тысяч; отменить можно только неоплаченный заказ. Всё остальное (каталог, корзина, личный кабинет) переносит данные. Переходный вариант стоит нескольких коротких интерфейсов (по одному на каждый репозиторий, которым пользуется код правил) и сразу убирает Spring Data из этого кода. Если отдельная модель так и не понадобится, лишнего написано немного: несколько коротких интерфейсов.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Вариант с отдельной моделью - когда правил много или видно, что их станет много.&lt;/strong&gt; Вот четыре признака, которые встречаются чаще других: при любом из них его стоит выбрать сразу, не проходя через переходный.&lt;/p&gt;

&lt;p&gt;&lt;u&gt;&lt;em&gt;Правила меняются чаще, чем схема базы.&lt;/em&gt;&lt;/u&gt; Банковские тарифы, расчёт страховки, условия акций в магазине: их правят каждый месяц, а таблицы остаются прежними. Если код таких правил работает с классами, размеченными под таблицы, правки правил и правки хранения то и дело попадают в одни и те же файлы, и каждую приходится проверять с оглядкой на другую.&lt;/p&gt;

&lt;p&gt;&lt;u&gt;&lt;em&gt;Схему базы задаёт кто-то другой.&lt;/em&gt;&lt;/u&gt; База досталась от старой системы, в неё пишут другие приложения, и менять в ней ничего нельзя. Колонки называются как-нибудь вроде &lt;code&gt;F_USR_ID&lt;/code&gt;; половина из них не используется. Если правила работают прямо с сущностями такой таблицы, в их коде появятся &lt;code&gt;F_USR_ID&lt;/code&gt; и непонятные числовые коды. С отдельной моделью у доменных классов понятные имена и те типы, которые нужны правилам, а перевод из чужой схемы собран в маппере.&lt;/p&gt;

&lt;p&gt;&lt;u&gt;&lt;em&gt;Одно правило нужно соблюдать во многих местах.&lt;/em&gt;&lt;/u&gt; Например, в магазине заказ отменяет покупатель, оператор, склад при нехватке товара и сама система, если заказ не оплачен вовремя. И везде действует одно правило: оплаченный заказ отменить нельзя. Если правило живёт в сервисе, а у сущности открыт сеттер состояния, каждый новый путь отмены - ещё одно место, где проверку можно забыть. В доменном объекте правило проверяется в методе, через который проходит любая отмена. А если такой путь появится в отдельном приложении (например, в ночной загрузке заказов от партнёров), доменный модуль без зависимостей подключается к нему целиком, не требуя ни базы, ни Spring.&lt;/p&gt;

&lt;p&gt;&lt;u&gt;&lt;em&gt;Решения принимаются по данным из разных источников.&lt;/em&gt;&lt;/u&gt; Например, скидка покупателю зависит от суммы его заказов, которая хранится в вашей базе, и от уровня в программе лояльности, которую ведёт внешний сервис. Правилу удобно видеть покупателя одним объектом с обоими значениями. Сущность так не устроена: она описывает одну таблицу, и сведения извне в неё можно положить только в поля, помеченные «не сохранять» (&lt;code&gt;@Transient&lt;/code&gt;) и заполняемые вручную. Доменный объект адаптер собирает из двух источников, и правило не знает, что один из них - база, а другой - сеть.&lt;/p&gt;

&lt;p&gt;Если ни один из этих признаков не про ваш проект и правил немного, отдельная модель сейчас не нужна. Начните с привычного или переходного варианта: перейти к отдельной модели можно в любой момент, по одному объекту. Порядок разобран в разделе «Как перейти, не останавливая работу». Делать это заранее, «чтобы потом не переделывать», незачем: пока правил мало, переделывать почти нечего.&lt;/p&gt;

&lt;h3&gt;Что выбрать для нашей платформы&lt;/h3&gt;

&lt;p&gt;Приложим всё это к примеру статьи. Перечислим задачи платформы и отметим, в каких код принимает решения.&lt;/p&gt;

&lt;table&gt;
	&lt;thead&gt;
		&lt;tr&gt;
			&lt;th&gt;Задача&lt;/th&gt;
			&lt;th&gt;Принимается ли решение&lt;/th&gt;
			&lt;th&gt;Что делает код&lt;/th&gt;
		&lt;/tr&gt;
	&lt;/thead&gt;
	&lt;tbody&gt;
		&lt;tr&gt;
			&lt;td&gt;Запись на курс&lt;/td&gt;
			&lt;td&gt;да&lt;/td&gt;
			&lt;td&gt;считает активные записи, сравнивает с тремя, может отказать&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr&gt;
			&lt;td&gt;Отмена записи&lt;/td&gt;
			&lt;td&gt;да&lt;/td&gt;
			&lt;td&gt;проверяет состояние: пройденный курс отменить нельзя&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr&gt;
			&lt;td&gt;Экран «мои курсы»&lt;/td&gt;
			&lt;td&gt;нет&lt;/td&gt;
			&lt;td&gt;читает строки и показывает на экране&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr&gt;
			&lt;td&gt;Каталог программ и запусков&lt;/td&gt;
			&lt;td&gt;нет&lt;/td&gt;
			&lt;td&gt;читает строки и показывает на экране&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr&gt;
			&lt;td&gt;Панель администратора: завести программу, запуск&lt;/td&gt;
			&lt;td&gt;нет&lt;/td&gt;
			&lt;td&gt;принимает форму и сохраняет строку&lt;/td&gt;
		&lt;/tr&gt;
	&lt;/tbody&gt;
&lt;/table&gt;

&lt;p&gt;Решения принимаются в двух задачах из пяти, и обе касаются одного объекта - записи на курс. Это случай из середины: правила уже есть, но их немного, и собраны они вокруг одного объекта.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Почему не привычный вариант.&lt;/strong&gt; Казалось бы, ради двух правил что-то менять незачем. Но вспомним тест правила про три курса из раздела про моки. При заглушке из трёх активных записей он одинаково проходит и на исправном сервисе, и на сервисе, из которого удалили отбор активных записей. Тест главного правила платформы не падает, когда правило сломано. Дописать тест со второй строки таблицы можно, но он поймает только ту поломку, которую автор предугадал. Надёжнее перенести отбор активных записей в запрос и проверить его тестом на настоящей базе, а для тестов правила завести реализацию порта в памяти и сверить её с настоящей общими проверками порта. Для этого нужен порт, а в привычном варианте его нет.&lt;/p&gt;

&lt;p&gt;Второй довод - операции, которые сервису не нужны. Сервис записи видит три репозитория по три десятка операций, среди которых удаление всей таблицы. На платформе, где таблица записей - это история обучения всех пользователей, такая операция в коде правил ни к чему.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Почему переходного варианта сегодня достаточно.&lt;/strong&gt; Пройдём по четырём признакам. Правила простые и пока не меняются. Схему таблиц платформы придумываете вы сами, снаружи её никто не задаёт. Приложение одно, и работает оно через браузер. Все данные, по которым принимаются решения, лежат в своей базе. Ни один признак не сработал.&lt;/p&gt;

&lt;p&gt;Что нужно сделать, показано в разделе о переходном варианте: три коротких интерфейса в домене (&lt;code&gt;CourseParticipations&lt;/code&gt;, &lt;code&gt;Users&lt;/code&gt; и &lt;code&gt;CourseRuns&lt;/code&gt;) и наследование от них в трёх интерфейсах Spring Data. Сущности прежние, второго набора классов и маппера нет. Взамен сервис записи видит пять операций вместо трёх наборов по три десятка, &lt;code&gt;@Query&lt;/code&gt; уезжает в инфраструктуру, а тест правила работает с реализацией порта.&lt;/p&gt;

&lt;p&gt;Запрет отменять пройденный курс при этом остаётся в сервисе, и это осознанная уступка. Пока путь отмены один (пользователь нажимает кнопку «отменить»), проверка тоже одна, и повторять её негде.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Почему не отдельная модель сразу.&lt;/strong&gt; Посчитаем, во что она обойдётся здесь. Для записи на курс - шесть файлов вместо двух и маппер, который придётся править с каждым новым полем. Получить за это можно одно: домен перестанет знать разметку таблицы. Сегодня это знание правилам не мешает. Правило про три курса не обращается ни к колонкам, ни к связям, а сама запись (пять полей: идентификатор, две связи, состояние и дата) вряд ли будет часто меняться. Шесть файлов решали бы задачу, которой у платформы сегодня нет.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Когда решение придётся пересмотреть.&lt;/strong&gt; Каждый из четырёх признаков на этой платформе может выглядеть вполне конкретно.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;&lt;u&gt;Лимит начинает зависеть от тарифа&lt;/u&gt;.&lt;/em&gt; Было «не больше трёх активных курсов». Стало: на бесплатном тарифе три, на платном без ограничений, на корпоративном - сколько оплатила компания, а курсы, которые компания назначила сотрудникам обязательными, в лимит не входят. Правило разрастается и меняется по решению отдела продаж, а таблица записей остаётся прежней. Это первый признак: правила меняются чаще схемы. Держать такое правило в коде, который работает с сущностями и их разметкой, становится неудобно: каждая правка тарифов идёт через файлы, связанные с устройством таблиц. С отдельной моделью сценарий записи работает только с доменными классами, и правило меняется отдельно от хранения.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;&lt;u&gt;Появляются новые пути отмены&lt;/u&gt;.&lt;/em&gt; Администратор отменяет записи вручную; при закрытии запуска курса отменяются все его записи; при возврате денег - записи пользователя. В каждом пути должен действовать запрет отменять пройденный курс. В переходном варианте проверка живёт в сервисе, а у сущности открыт &lt;code&gt;setStatus&lt;/code&gt;, так что каждый новый путь - ещё одно место, где проверку можно забыть. Это третий признак: одно правило во многих местах. С отдельной моделью запрет проверяется в методе &lt;code&gt;cancel&lt;/code&gt;, и другого способа отменить запись у сценариев нет. Если же отмену делает отдельное приложение (скажем, ночная обработка файлов, которые присылает корпоративный клиент), доменный модуль подключается к нему целиком, вместе с правилом.&lt;/p&gt;

&lt;p&gt;&lt;u&gt;&lt;em&gt;Оплата уезжает во внешний сервис.&lt;/em&gt;&lt;/u&gt; Записаться можно только с оплаченной подпиской, а сведения о подписках хранит платёжная система; в базе платформы их нет. Пока нужно одно значение («оплачена ли подписка»), хватит ещё одного порта, и переходный вариант с этим справится. Но когда правилу нужен пользователь целиком (курсы из своей базы, тариф и дата окончания подписки из платёжной системы), удобнее собрать его доменным объектом из двух источников, чем дописывать в сущность поля, которых нет в таблице. Это четвёртый признак.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;&lt;u&gt;Платформу разворачивают поверх чужой базы&lt;/u&gt;.&lt;/em&gt; Крупный клиент ведёт сотрудников и обучение в своей системе и менять в ней ничего не даёт. Колонки там называются &lt;code&gt;F_USR_ID&lt;/code&gt; и &lt;code&gt;C_STAT&lt;/code&gt;, половина полей платформе не нужна, а состояние хранится числом, где &lt;code&gt;2&lt;/code&gt; означает «отчислен». Если правила работают прямо с сущностями этой таблицы, в коде платформы появятся &lt;code&gt;F_USR_ID&lt;/code&gt; и проверки вида «состояние равно двум». Это второй признак, и отдельная модель здесь нужна: у доменного объекта понятные имена и состояние типа &lt;code&gt;ParticipationStatus&lt;/code&gt;, а перевод из чужой схемы собран в одном маппере.&lt;/p&gt;

&lt;p&gt;Пока ничего из этого не случилось, переходного варианта достаточно. Когда случится, переход делается по одному объекту и не требует останавливать работу над задачами; порядок разобран в разделе «Как перейти, не останавливая работу».&lt;/p&gt;

&lt;h2&gt;Уровни строгости&lt;/h2&gt;

&lt;p&gt;До сих пор речь шла о том, как написать код. Остался вопрос, как сохранить написанное. Через полгода правок в доменный класс легко вернётся импорт из инфраструктуры: по невнимательности, ради быстрого исправления или просто потому, что среда разработки сама предложила подходящий класс из чужого пакета.&lt;/p&gt;

&lt;p&gt;Удержать границу помогают разные средства, и различаются они строгостью - тем, насколько трудно нарушить границу незаметно. Разберём три, которые встречаются чаще других. Код во всех трёх случаях устроен одинаково: порт в домене, реализация в инфраструктуре. Различается то, кто заметит нарушение.&lt;/p&gt;

&lt;p style="text-align:center;"&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/12054155/pr-2-urovni-strogosti.png/af609c08-7ef4-6edd-01d7-47e37551611e?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p style="text-align:center;"&gt;&amp;nbsp;&lt;/p&gt;

&lt;p style="text-align:center;"&gt;&lt;em&gt;Рисунок 2. Код во всех трёх случаях один и тот же - меняется то, кто замечает нарушение границы: люди, тест или компилятор. Чем правее, тем больше настройки и тем труднее нарушить границу незаметно.&lt;/em&gt;&lt;/p&gt;

&lt;h3&gt;Пакеты&lt;/h3&gt;

&lt;p&gt;Пакет в Java - папка с классами, имя которой входит в полное имя класса: &lt;code&gt;com.example.courses.domain.CourseParticipation&lt;/code&gt;. На этом уровне порт лежит в пакете &lt;code&gt;domain&lt;/code&gt;, адаптер - в пакете &lt;code&gt;persistence&lt;/code&gt;, и оба - в одном модуле сборки.&lt;/p&gt;

&lt;p&gt;Следить за границей здесь некому. Компилятор не возразит против импорта из &lt;code&gt;persistence&lt;/code&gt; в &lt;code&gt;domain&lt;/code&gt;: модуль один, и открытые классы видны друг другу. Граница держится на том, что все в команде о ней помнят.&lt;/p&gt;

&lt;p&gt;Ничего, кроме внимания людей, этот уровень не требует: разложить классы по пакетам среда разработки позволяет командой перемещения.&lt;/p&gt;

&lt;h3&gt;Пакеты и тест&lt;/h3&gt;

&lt;p&gt;Те же пакеты плюс тест, который проверяет границу при каждой сборке. Такие проверки умеет ArchUnit - библиотека для тестов, которая читает скомпилированные классы и проверяет, какие классы от каких зависят:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
class ArchitectureTest {

    private final JavaClasses classes = new ClassFileImporter()
        .withImportOption(ImportOption.Predefined.DO_NOT_INCLUDE_TESTS)
        .importPackages("com.example.courses");

    @Test
    void домен_не_знает_про_фреймворки() {
        noClasses()
            .that().resideInAPackage("..courses.domain..")
            .should().dependOnClassesThat()
            .resideInAnyPackage("org.springframework..", "jakarta.persistence..",
                                "..courses.persistence..")
            .because("домен описывает правила предметной области "
                   + "и не должен зависеть от способа хранения")
            .check(classes);
    }

    @Test
    void сценарии_не_знают_про_инфраструктуру() {
        noClasses()
            .that().resideInAPackage("..courses.application..")
            .should().dependOnClassesThat()
            .resideInAnyPackage("..courses.persistence..",
                                "org.springframework.data..",
                                "jakarta.persistence..")
            .because("сценарий работает с портом, а не с базой")
            .check(classes);
    }
}
&lt;/pre&gt;

&lt;p&gt;Первый тест запрещает классам из пакета домена зависеть от Spring и JPA. Второй запрещает сценариям обращаться к инфраструктуре, к Spring Data и к JPA. Добавил кто-то запрещённый импорт - тест падает, и сборка не проходит. В &lt;code&gt;because&lt;/code&gt; записана причина запрета: она попадёт в сообщение об ошибке, и человек, увидевший упавший тест через год, узнает не только что запрещено, но и почему.&lt;/p&gt;

&lt;p&gt;Этот тест написан для варианта с отдельной моделью. В переходном варианте сущности с аннотациями JPA законно лежат в домене, поэтому &lt;code&gt;jakarta.persistence..&lt;/code&gt; из первого правила убирают; подробнее - в разделе «Как перейти, не останавливая работу», на пятом шаге.&lt;/p&gt;

&lt;p&gt;Обходится это одним файлом и несколькими секундами на каждой сборке. Взамен граница перестаёт зависеть от памяти людей. Нарушают её обычно не намеренно, а по невнимательности, и тест ловит как раз такие случаи.&lt;/p&gt;

&lt;h3&gt;Модули сборки&lt;/h3&gt;

&lt;p&gt;Код разнесён по подпроектам Maven, как в варианте с отдельной моделью. В &lt;code&gt;pom.xml&lt;/code&gt; доменного модуля одна зависимость - библиотека для тестов:&lt;/p&gt;

&lt;pre class="brush:xml;"&gt;
&amp;lt;artifactId&amp;gt;courses-domain&amp;lt;/artifactId&amp;gt;

&amp;lt;dependencies&amp;gt;
    &amp;lt;dependency&amp;gt;
        &amp;lt;groupId&amp;gt;org.junit.jupiter&amp;lt;/groupId&amp;gt;
        &amp;lt;artifactId&amp;gt;junit-jupiter&amp;lt;/artifactId&amp;gt;
        &amp;lt;scope&amp;gt;test&amp;lt;/scope&amp;gt;
    &amp;lt;/dependency&amp;gt;
&amp;lt;/dependencies&amp;gt;
&lt;/pre&gt;

&lt;p&gt;Здесь за границей следит компилятор. Написать &lt;code&gt;@Entity&lt;/code&gt; в доменном коде нельзя: этой аннотации нет среди того, что доступно модулю при компиляции. Сослаться из домена на инфраструктуру тоже нельзя: инфраструктура уже зависит от домена, и Maven откажется собирать модули, которые ссылаются друг на друга по кругу.&lt;/p&gt;

&lt;p&gt;В третьей части серии предложена проверка, настоящая ли инверсия: удалить модуль хранения из сборки и попробовать скомпилировать модуль с бизнес-логикой. Здесь её можно выполнить буквально. Уберите &lt;code&gt;courses-persistence&lt;/code&gt; из сборки и соберите домен. Собрался - инверсия настоящая.&lt;/p&gt;

&lt;p&gt;Обходится этот уровень дороже теста: несколько файлов &lt;code&gt;pom.xml&lt;/code&gt;, более долгая полная сборка, а переносить классы между модулями сложнее, чем между пакетами. И есть требование к именам пакетов. Запуском приложения занимается Spring Boot (надстройка над Spring, которая собирает приложение с готовыми настройками). Классы приложения Spring Boot ищет в пакете, где лежит класс с аннотацией &lt;code&gt;@SpringBootApplication&lt;/code&gt;, и во всех вложенных в него пакетах. Если у модулей разные корневые пакеты, область поиска придётся перечислять вручную, аннотациями &lt;code&gt;@ComponentScan&lt;/code&gt;, &lt;code&gt;@EnableJpaRepositories&lt;/code&gt; и &lt;code&gt;@EntityScan&lt;/code&gt;. Проще дать всем модулям общий корень, как здесь: &lt;code&gt;com.example.courses&lt;/code&gt;.&lt;/p&gt;

&lt;table&gt;
	&lt;thead&gt;
		&lt;tr&gt;
			&lt;th&gt;Уровень&lt;/th&gt;
			&lt;th&gt;Кто замечает нарушение&lt;/th&gt;
			&lt;th&gt;Во что обходится&lt;/th&gt;
			&lt;th&gt;Когда выбирать&lt;/th&gt;
		&lt;/tr&gt;
	&lt;/thead&gt;
	&lt;tbody&gt;
		&lt;tr&gt;
			&lt;td&gt;Пакеты&lt;/td&gt;
			&lt;td&gt;люди, если помнят&lt;/td&gt;
			&lt;td&gt;ничего не стоит&lt;/td&gt;
			&lt;td&gt;небольшой проект, который пишет один человек&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr&gt;
			&lt;td&gt;Пакеты и тест&lt;/td&gt;
			&lt;td&gt;тест при каждой сборке&lt;/td&gt;
			&lt;td&gt;один файл&lt;/td&gt;
			&lt;td&gt;почти всегда&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr&gt;
			&lt;td&gt;Модули сборки&lt;/td&gt;
			&lt;td&gt;компилятор&lt;/td&gt;
			&lt;td&gt;несколько &lt;code&gt;pom.xml&lt;/code&gt;, сборка дольше&lt;/td&gt;
			&lt;td&gt;домен нужно собирать без инфраструктуры&lt;/td&gt;
		&lt;/tr&gt;
	&lt;/tbody&gt;
&lt;/table&gt;

&lt;p&gt;Начинать стоит со второй строки - с пакетов и теста. Первая годится для небольшого проекта, который пишет один человек: следить за границей там и так некому, кроме автора. В модули сборки код чаще всего выносят в двух случаях. Первый: тест границы начинает регулярно ловить нарушения, то есть запрещённые импорты то и дело пытаются добавить, и надёжнее, чтобы их не пропускал сам компилятор. Второй: появилась причина собирать домен отдельно: например, его правила понадобились второму приложению.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Для специалистов с опытом:&lt;/strong&gt; модулями Maven способы провести границу не исчерпываются. Система модулей самой Java (файл &lt;code&gt;module-info.java&lt;/code&gt; с объявлениями &lt;code&gt;requires&lt;/code&gt; и &lt;code&gt;exports&lt;/code&gt;) проверяется и компилятором, и виртуальной машиной при запуске, но в приложениях на Spring Boot встречается редко. Одна из причин механическая: исполняемый jar-файл Spring Boot хранит библиотеки вложенными jar-файлами; стандартного способа загружать их в Java нет, поэтому Spring Boot использует собственный загрузчик классов. Кроме того, приложение запускается с пути классов, где модульные границы не действуют, а многие библиотеки объявляют только &lt;code&gt;Automatic-Module-Name&lt;/code&gt; вместо полного описания модуля. Другой способ - Spring Modulith: модулем там считается каждый пакет, непосредственно вложенный в пакет класса с &lt;code&gt;@SpringBootApplication&lt;/code&gt;, а границы описываются аннотациями и проверяются тестом. По строгости это тот же второй уровень, только правила для теста уже написаны.&lt;/p&gt;

&lt;h2&gt;Что не нужно инвертировать&lt;/h2&gt;

&lt;p&gt;Приём легко испортить, применив его ко всему подряд. Каждый интерфейс - лишний шаг при чтении кода: переходя по вызову, читатель попадает в объявление, а не в работающий код. В третьей части серии этой цене отведён отдельный раздел; здесь разговор доходит до конкретных методов хранилища.&lt;/p&gt;

&lt;p&gt;Вернёмся к исходному репозиторию. Метод &lt;code&gt;findAllForUser&lt;/code&gt; обслуживал две задачи: сервис записи брал из него записи пользователя, чтобы посчитать активные, а экран «мои курсы» - чтобы показать список с названиями программ. В варианте с отдельной моделью первая задача ушла в порт (метод &lt;code&gt;findActiveForUser&lt;/code&gt;). Вторая пока осталась без хозяина.&lt;/p&gt;

&lt;p&gt;Решить, куда её деть, помогает один вопрос, который стоит задать каждому методу хранилища: &lt;strong&gt;принимает ли бизнес-логика решение по результату этого метода?&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Если да, метод идёт в порт. По активным записям сценарий решает, записывать ли пользователя на курс, поэтому &lt;code&gt;findActiveForUser&lt;/code&gt; - в порту.&lt;/li&gt;
	&lt;li&gt;Если нет и результат просто показывают на экране или выводят в отчёт, метод остаётся прямым обращением к базе через Spring Data, без порта, доменного объекта и маппера.&lt;/li&gt;
&lt;/ul&gt;

&lt;p style="text-align:center;"&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/12054155/pr-3-dva-puti.png/8a8c94c2-5f83-c967-ce2d-45846f00af58?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p style="text-align:center;"&gt;&amp;nbsp;&lt;/p&gt;

&lt;p style="text-align:center;"&gt;&lt;em&gt;Рисунок 3. Запись на курс проходит через правила: по прочитанным записям принимается решение. Список для экрана решений не требует и читается из базы напрямую.&lt;/em&gt;&lt;/p&gt;

&lt;h3&gt;Запросы для экранов&lt;/h3&gt;

&lt;p&gt;Экран «мои курсы» ничего не решает: он показывает то, что есть в базе. Если вести его данные через порт, адаптер, доменный объект и маппер, придётся написать четыре класса и ничего не получить взамен: правил, которые стоило бы отделять от хранения, здесь нет.&lt;/p&gt;

&lt;p&gt;Таким запросам подходит прямое обращение к базе:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
package com.example.courses.persistence;

public record ParticipationListItem(
        Long participationId,
        Long courseRunId,
        String programTitle,
        ParticipationStatus status,
        Instant enrolledAt) {
}
&lt;/pre&gt;

&lt;pre class="brush:java;"&gt;
public interface ParticipationQueries
        extends Repository&amp;lt;CourseParticipationEntity, Long&amp;gt; {

    @Query("""
        select new com.example.courses.persistence.ParticipationListItem(
                   p.id, r.id, prog.title, p.status, p.enrolledAt)
          from CourseParticipationEntity p
          join p.courseRun r
          join r.program prog
         where p.user.id = :userId
         order by p.enrolledAt desc
        """)
    List&amp;lt;ParticipationListItem&amp;gt; findForUser(@Param("userId") Long userId);
}
&lt;/pre&gt;

&lt;p&gt;Здесь стоит остановиться на двух решениях.&lt;/p&gt;

&lt;p&gt;Первое: интерфейс наследует &lt;code&gt;Repository&lt;/code&gt;, а не &lt;code&gt;JpaRepository&lt;/code&gt;. &lt;code&gt;Repository&lt;/code&gt; - пустой интерфейс Spring Data. Он не объявляет ни одного метода и служит только меткой: «создай для этого интерфейса реализацию». Поэтому у &lt;code&gt;ParticipationQueries&lt;/code&gt; есть только то, что объявлено в нём самом: ни &lt;code&gt;save&lt;/code&gt;, ни &lt;code&gt;deleteAll&lt;/code&gt;, ни &lt;code&gt;findAll&lt;/code&gt;. Коду, которому нужно только читать, и не нужно уметь писать; теперь это обеспечивает объявление интерфейса, а не договорённость.&lt;/p&gt;

&lt;p&gt;Второе: вместо &lt;code&gt;join fetch&lt;/code&gt; запрос собирает &lt;strong&gt;проекцию&lt;/strong&gt; - объект, в котором только те поля, что нужны экрану. Конструкция &lt;code&gt;select new ...ParticipationListItem(...)&lt;/code&gt; прямо в запросе говорит, из каких полей и какой объект собрать. Сущности при этом не создаются, связанные объекты не загружаются, и проблемы N+1 не возникает: подтягивать связи заранее не нужно, потому что они не нужны вовсе.&lt;/p&gt;

&lt;p&gt;Оба типа лежат в модуле &lt;code&gt;courses-persistence&lt;/code&gt;, в пакете &lt;code&gt;com.example.courses.persistence&lt;/code&gt;, каждый в своём файле: &lt;code&gt;ParticipationListItem.java&lt;/code&gt; и &lt;code&gt;ParticipationQueries.java&lt;/code&gt;. Реализацию интерфейса, как и для любого репозитория, создаёт Spring Data при запуске приложения.&lt;/p&gt;
&lt;p&gt;Вызывает &lt;code&gt;ParticipationQueries&lt;/code&gt; веб-слой из модуля &lt;code&gt;courses-app&lt;/code&gt;, причём напрямую, минуя сценарии и домен. Выглядит это так:&lt;/p&gt;
&lt;pre class="brush:java;"&gt;package com.example.courses.web;
 
@RestController
class MyCoursesController {
 
    private final ParticipationQueries queries;
 
    MyCoursesController(ParticipationQueries queries) {
        this.queries = queries;
    }
 
    @GetMapping(&amp;quot;/users/{userId}/courses&amp;quot;)
    List&amp;lt;ParticipationListItem&amp;gt; myCourses(@PathVariable Long userId) {
        return queries.findForUser(userId);
    }
}
&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;@RestController&lt;/code&gt; сообщает Spring, что объект этого класса принимает запросы из браузера и возвращает ответ в виде данных (обычно в формате JSON). &lt;code&gt;@GetMapping&lt;/code&gt; связывает метод с адресом, а &lt;code&gt;@PathVariable&lt;/code&gt; берёт &lt;code&gt;userId&lt;/code&gt; из самого адреса. Контроллер получает &lt;code&gt;ParticipationQueries&lt;/code&gt; через конструктор и возвращает то, что отдал запрос: решать здесь нечего.&lt;/p&gt;
&lt;p&gt;Из-за этого интерфейс, в отличие от адаптера, объявлен &lt;code&gt;public&lt;/code&gt;: его имя нужно другому модулю, &lt;code&gt;courses-app&lt;/code&gt;. Сценариям пользоваться им не положено: они работают через порт. При раскладке по модулям нарушить это не даст уже компилятор, ведь модуль сценариев от инфраструктуры не зависит. При раскладке по пакетам сработает общий запрет из раздела «Уровни строгости»: он не пускает сценарии во весь пакет &lt;code&gt;persistence&lt;/code&gt;. Но запрет можно сформулировать и точнее: не «сценариям нельзя в инфраструктуру», а «запросами для экранов не пользуется никто, кроме веб-слоя». Для этого в тест границы добавляется ещё одно правило:&lt;/p&gt;
&lt;pre class="brush:java;"&gt;@Test
void запросы_для_экранов_вызывает_только_веб_слой() {
    noClasses()
        .that().resideOutsideOfPackages(&amp;quot;..courses.web..&amp;quot;, &amp;quot;..courses.persistence..&amp;quot;)
        .should().dependOnClassesThat().haveSimpleNameEndingWith(&amp;quot;Queries&amp;quot;)
        .because(&amp;quot;запросы для экранов идут в базу мимо правил; &amp;quot;
               + &amp;quot;пользоваться ими может только веб-слой&amp;quot;)
        .check(classes);
}
&lt;/pre&gt;
&lt;p&gt;Правило опирается на соглашение об именах: всё, что читает данные для экранов, называется &lt;code&gt;...Queries&lt;/code&gt;, и новый интерфейс запросов попадёт под запрет без правки теста. Пакет &lt;code&gt;persistence&lt;/code&gt; исключён из проверки, потому что сами интерфейсы запросов лежат в нём. Если кто-то обратится к &lt;code&gt;ParticipationQueries&lt;/code&gt; из сценария или из доменного класса, тест упадёт с сообщением из &lt;code&gt;because&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Так у одного репозитория привычного варианта появилось два преемника с разными задачами: порт на три операции для правил и интерфейс запросов для экранов. Интерфейс Spring Data за портом тоже остался, но его видит только адаптер.&lt;/p&gt;
&lt;h3&gt;Не нарушает ли прямой запрос разделение?&lt;/h3&gt;
&lt;p&gt;Здесь напрашиваются три вопроса. Разберём их по очереди.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Не ломает ли запрос для экрана то разделение, ради которого всё затевалось?&lt;/strong&gt; Нет, и это видно по направлению зависимостей:&lt;/p&gt;
&lt;pre class="brush:plain;"&gt;courses-app (веб-слой) ──▶ courses-persistence ──▶ courses-domain
                                                    (ни от кого)
&lt;/pre&gt;
&lt;p&gt;Разделение запрещает домену и сценариям зависеть от хранения. Запрос для экрана этого запрета не нарушает: он лежит в инфраструктуре, а пользуется им веб-слой, который и так зависит от всех трёх модулей, потому что собирает из них приложение. Домен по-прежнему собирается в одиночку, и в нём не появилось ни одной строки о таблицах.&lt;/p&gt;
&lt;p&gt;Цена у такого решения есть: экран знает устройство таблиц, и переименование колонки заденет запрос для экрана. Но это код экрана; файл с правилом про три курса останется прежним, а ради этого разделение и делалось.&lt;/p&gt;
&lt;p&gt;Следить нужно за другим. Как только экран начинает что-то решать (например, показывать кнопку «Отменить» только у тех записей, которые разрешено отменить), это уже бизнес-правило. Его нельзя дописывать в запрос или в шаблон страницы: ответ должен приходить из домена, иначе одно правило окажется записано в двух местах.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Разве &lt;code&gt;ParticipationListItem&lt;/code&gt; - не тот же маппер?&lt;/strong&gt; Нет. &lt;code&gt;ParticipationListItem&lt;/code&gt; - результат переноса, то есть объект с данными, как и доменный &lt;code&gt;CourseParticipation&lt;/code&gt;. Роль маппера здесь играет сам запрос: выражение &lt;code&gt;select new ...ParticipationListItem(p.id, r.id, prog.title, p.status, p.enrolledAt)&lt;/code&gt; говорит Hibernate, какие колонки взять и в какой конструктор их передать. Сравним два пути:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;через правила: строка таблицы → сущность → маппер &lt;code&gt;toDomain&lt;/code&gt; → доменный объект;&lt;/li&gt;
&lt;li&gt;для экрана: строки таблиц → &lt;code&gt;select new&lt;/code&gt; → &lt;code&gt;ParticipationListItem&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Во втором пути один шаг вместо трёх, и сущности не создаются вовсе.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Почему бы не вести экран через порт?&lt;/strong&gt; Можно, но экран от этого ничего не получит, а домен кое-что потеряет.&lt;/p&gt;
&lt;p&gt;Первое: доменному объекту не хватает данных. У &lt;code&gt;CourseParticipation&lt;/code&gt; нет названия программы, только &lt;code&gt;courseRunId&lt;/code&gt;, потому что правилам название не нужно. Чтобы показать список через порт, пришлось бы либо добавить в доменный объект поле ради экрана (и тогда домен начал бы меняться вслед за дизайном страниц), либо объявить в порту отдельный тип для экрана (и тогда домен знал бы про экраны).&lt;/p&gt;
&lt;p&gt;Второе: порт начал бы расти. Сейчас в нём три метода, нужные правилам. Каждый новый список, фильтр и сортировка добавляли бы в него метод, и порт постепенно превратился бы в копию &lt;code&gt;JpaRepository&lt;/code&gt;: правила снова видели бы десятки ненужных им операций.&lt;/p&gt;
&lt;p&gt;Третье: защищать нечего. Порт даёт правилам независимость от хранения и проверку без базы. Правил на экране нет, а проверять у него нужно сам запрос (правильно ли соединены таблицы, верна ли сортировка), и такой тест в любом случае идёт на настоящей базе.&lt;/p&gt;
&lt;p&gt;Через домен экран стоит вести в двух случаях. Первый: экран показывает то, что вычисляют правила, например «осталось одно место из трёх» или «запись можно отменить». Второй: данные для экрана приходят не из вашей базы, а из внешнего сервиса; тогда нужен интерфейс, но объявленный для экрана, а не доменный порт.&lt;/p&gt;
&lt;p&gt;У такого устройства есть название - CQRS (от английского Command Query Responsibility Segregation, «разделение ответственности команд и запросов»): изменения идут через правила, чтение для показа идёт напрямую. Здесь оно применено в самой простой форме: база одна, разделены только пути в коде.&lt;/p&gt;
&lt;h3&gt;Классы, которые меняются вместе&lt;/h3&gt;

&lt;p&gt;Второе место, где интерфейс обычно лишний, - связь между классами, которые лежат в одном модуле и меняются вместе. Пусть на платформе есть класс, который считает стоимость курса, и класс, который применяет к ней скидку. Оба в домене, оба меняются, когда отдел продаж пересматривает цены, и выходят в одной версии приложения. Интерфейс между ними ничего не даёт. Он нужен, чтобы одну сторону можно было заменить, не трогая другую, а заменять нечего: второго способа считать стоимость в системе нет.&lt;/p&gt;

&lt;p&gt;Напрашивается возражение: а вдруг появится? Тогда сработает ориентир из третьей части: инвертировать стоит там, где можно внятно назвать второй возможный вариант реализации. Как только второй способ расчёта можно назвать, интерфейс оправдан, и основную часть работы по его извлечению из класса сделает среда разработки. Заводить его заранее, под предположение, - значит сразу платить лишним шагом при чтении кода и ничего пока не получать.&lt;/p&gt;

&lt;p&gt;С хранилищем дело обстоит иначе: вторая реализация у него есть с самого начала: реализация в памяти для тестов. Настоящее хранилище ходит в базу, и без замены тест правила пришлось бы запускать вместе с базой. Расчёт стоимости в тесте вызывается напрямую: он ничего не читает извне, и заменять его незачем.&lt;/p&gt;

&lt;h2&gt;Как перейти, не останавливая работу&lt;/h2&gt;

&lt;p&gt;Переписывать весь проект за один заход незачем, да и не выйдет: задачи не перестанут приходить на время переделки. Двигаться можно по шагам, и каждый шаг укладывается в обычную рабочую задачу.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Шаг первый. Выберите один объект предметной области.&lt;/strong&gt; Лучше тот, что меняется чаще других: на нём быстрее станет видно, что даёт переделка. А если где-то ошибиться (скажем, отправить в порт лишний метод), ошибка затронет одну задачу, а не десять.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Шаг второй. Разделите методы его репозитория.&lt;/strong&gt; Тем самым вопросом из раздела «Что не нужно инвертировать»: принимает ли бизнес-логика решение по результату метода. Это упражнение на бумаге, код оно не трогает. Обычно выходит так: два-три метода - в порт, остальные - в интерфейс запросов для экранов.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Шаг третий. Объявите порт и переведите на него сервисы.&lt;/strong&gt; Пока без отдельной модели: интерфейс Spring Data наследует порт, как в переходном варианте. Работы немного: объявить интерфейс в домене и поменять типы в конструкторах сервисов, которые пользуются репозиторием. Зависимость этих сервисов от Spring Data исчезает сразу.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Шаг четвёртый. Напишите вторую реализацию порта и переведите на неё тесты правил.&lt;/strong&gt; На этом шаге появляется польза, которую видно в ежедневной работе: тесты правил перестают опираться на мок чужого интерфейса и работают с вашей собственной реализацией - одной на все сервисы. Сверьте её с настоящим хранилищем общими проверками порта, как описано в разделе «Тест, которому не нужна база». Если дальше не идти, сделанного уже достаточно, чтобы переделка оправдалась: сервисы не зависят от Spring Data, а тесты правил не требуют базы и не прячут в заглушках предположений о запросах.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Шаг пятый. Поставьте тест на границу.&lt;/strong&gt; Тест ArchUnit для одного пакета - того, где лежит выбранный объект. На этом шаге правило запрещает домену только &lt;code&gt;org.springframework..&lt;/code&gt;. Пакет &lt;code&gt;jakarta.persistence..&lt;/code&gt; добавляется в запрет после шестого шага, иначе тест упадёт на &lt;code&gt;@Entity&lt;/code&gt;, которой на этой ступени в домене место. Такой тест не даст сделанному откатиться назад, пока вы заняты другими объектами.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Шаг шестой, если нужен. Разделите модели.&lt;/strong&gt; Доменный объект без аннотаций, сущность отдельно, маппер между ними. Здесь впервые станет видно, во что обходится маппер на живом объекте: сколько в нём кода и как часто его приходится править вместе с полями. Решение про остальные объекты получится принимать, зная это, а не по общим соображениям.&lt;/p&gt;

&lt;p&gt;Шаги идут в таком порядке не случайно: каждый полезен сам по себе и не требует следующего. Остановиться после любого можно, и ни один не придётся отменять, чтобы продолжить. Шестой шаг, правда, правит сделанное раньше: в объявлениях порта &lt;code&gt;Long&lt;/code&gt; сменяется на &lt;code&gt;ParticipationId&lt;/code&gt; и &lt;code&gt;UserId&lt;/code&gt;, сущность - на доменный объект, а в тест границы добавляется &lt;code&gt;jakarta.persistence..&lt;/code&gt;. Но порт, его реализация в памяти и тесты остаются на своих местах.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Практический ориентир:&lt;/strong&gt; после третьего шага поищите в файлах сервисов &lt;code&gt;org.springframework.data&lt;/code&gt;, &lt;code&gt;JpaRepository&lt;/code&gt;, &lt;code&gt;Pageable&lt;/code&gt; и имена интерфейсов Spring Data. Пусто - шаг сделан. Что-то нашлось - порт пока только для вида. Искать в сервисах &lt;code&gt;@Entity&lt;/code&gt; бесполезно: эта аннотация стоит на классе сущности, а не на сервисе, и поиск ничего не найдёт ни до переделки, ни после.&lt;/p&gt;

&lt;h2&gt;Типичные ошибки&lt;/h2&gt;

&lt;p&gt;Вот четыре частых способа провести инверсию формально и не получить того, ради чего она делается. Первые две разобраны в третьей части серии на другом примере, остальные две встречаются именно в проектах на Spring.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Порт, повторяющий &lt;code&gt;JpaRepository&lt;/code&gt;.&lt;/strong&gt; Интерфейс объявлен в домене, но содержит &lt;code&gt;findAll&lt;/code&gt;, &lt;code&gt;deleteById&lt;/code&gt;, &lt;code&gt;count&lt;/code&gt; и &lt;code&gt;saveAll&lt;/code&gt; про запас. Пользы от него нет: правила снова получили те же операции, только перечисленные вручную. Порт описывает то, что нужно вызывающей стороне, а не то, что умеет реализация.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Порт в модуле инфраструктуры.&lt;/strong&gt; Интерфейс лежит рядом с реализацией, а сервисы с правилами импортируют его оттуда. Зависимость осталась направленной от правил к хранению, просто классов в системе стало больше. В третьей части этому посвящён раздел «Кому принадлежит интерфейс», и вывод там такой: интерфейс стоит объявлять в модуле, который им пользуется, а не в том, который его реализует.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Типы Spring Data в объявлениях методов порта.&lt;/strong&gt; Один &lt;code&gt;Pageable&lt;/code&gt; в объявлении - и доменный модуль больше не собирается без Spring Data. Порт формально на месте, а зависимость вернулась.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Сущность, пришедшая в домен через параметр.&lt;/strong&gt; Порт объявлен правильно, но один из его методов принимает класс с &lt;code&gt;@Entity&lt;/code&gt;, потому что так проще было написать адаптер. При разнесении по модулям сборки такой код даже не соберётся, а при разнесении по пакетам соберётся, и домен окажется зависим от JPA. По сути это переходный вариант, только решение о нём не принималось и нигде не записано.&lt;/p&gt;

&lt;p&gt;Три из четырёх ошибок ловятся механически. Если модули домена и сценариев не собираются без &lt;code&gt;courses-persistence&lt;/code&gt;, порт лежит не там. Если доменный модуль не собирается, когда из его &lt;code&gt;pom.xml&lt;/code&gt; убраны все зависимости, кроме тестовой, в объявлениях порта есть типы Spring Data или сущности.&lt;/p&gt;

&lt;p&gt;Порт, повторяющий &lt;code&gt;JpaRepository&lt;/code&gt;, так не поймать: он собран из доменных типов и соберётся без ошибок. Здесь помогает только чтение: посмотрите, сколько методов объявлено в порту и сколькими из них пользуются сервисы.&lt;/p&gt;

&lt;h2&gt;Заключение&lt;/h2&gt;

&lt;p&gt;Мы начали с интерфейса Spring Data и правила «не больше трёх активных курсов». Подведём итог.&lt;/p&gt;

&lt;p&gt;Привычный вариант не ошибочен: он даёт готовые операции, обходится одним классом на запись и хорошо знаком тем, кто работал со Spring. Платит он четырьмя следствиями: сервис зависит от разметки таблицы, получает около трёх десятков ненужных операций в каждом репозитории, проверяется только через заглушку, которая ничего не говорит о настоящем запросе, и держит правила у себя, а не в объекте, к которому они относятся. Ни одно из них не следует из задачи.&lt;/p&gt;

&lt;p&gt;Порт - интерфейс, который объявляют правила и который лежит рядом с ними. Важнее всего в нём то, чего в нём нет. Наследование от &lt;code&gt;JpaRepository&lt;/code&gt;, типы Spring Data и запросы не должны попадать в него ни в одном варианте: с ними интерфейс остаётся только для вида. Сущности в порту допустимы лишь в переходном варианте, и это осознанная уступка, о которой стоит помнить.&lt;/p&gt;

&lt;p&gt;Интерфейс Spring Data при этом никуда не исчезает. Он переезжает в инфраструктуру и продолжает давать свои готовые операции, только получает их теперь адаптер, а не код правил. Туда же переезжает &lt;code&gt;@Query&lt;/code&gt;, а вместе с ней и решение о том, каким запросом доставать данные.&lt;/p&gt;

&lt;p&gt;Три варианта различаются не правильностью, а тем, сколько кода приходится написать и сколько сведений о базе остаётся в коде правил. Переходный закрывает два следствия из четырёх и обходится без маппера. Вариант с отдельной моделью закрывает все четыре и требует на каждый объект второго класса и маппера. Выбор зависит от того, сколько в проекте кода, принимающего решения: платформе из примера с её двумя правилами сегодня хватает переходного варианта, а к отдельной модели стоит переходить, когда лимит начнёт зависеть от тарифа, появятся новые пути отмены, данные для решений придут извне или схему продиктует чужая база.&lt;/p&gt;

&lt;p&gt;Удержать границу помогают средства разной строгости. Пакеты полагаются на память людей, тест ArchUnit проверяет границу при каждой сборке, модули Maven передают проверку компилятору. Направление зависимостей при этом везде одно, меняется только то, кто замечает его нарушение.&lt;/p&gt;

&lt;p&gt;Инвертировать стоит не всё. Если по результату метода бизнес-логика принимает решение, метод идёт в порт. Если он поставляет данные для экрана или отчёта, он остаётся прямым обращением к базе. Из одного репозитория обычно получаются два интерфейса, и это не компромисс: у проверки правил и у показа данных разные задачи.&lt;/p&gt;

&lt;p&gt;Перейти можно по одному объекту, и польза появляется не в конце, а уже на третьем и четвёртом шагах из шести: сервисы перестают зависеть от Spring Data, а тесты правил - от моков. Остановиться можно после любого шага.&lt;/p&gt;

&lt;p&gt;И проверка, которую можно провести руками за минуту: оставьте в &lt;code&gt;pom.xml&lt;/code&gt; доменного модуля только тестовую зависимость и уберите из сборки остальные модули. Если домен собирается в одиночку, инверсия настоящая. Для переходного варианта эта проверка не годится: там в домене законно остаётся &lt;code&gt;jakarta.persistence-api&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Спасибо, что дочитали до конца.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Следующая часть серии - та, что была обещана в конце третьей: функциональное программирование. Поговорим о том, почему ограничение на присваивание оказалось не причудой математиков, что такое функциональное ядро в императивной оболочке и почему хранение событий вместо текущего состояния меняет взгляд на устройство данных.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Следите за продолжением.&lt;/strong&gt;&lt;/p&gt;</summary>
    <dc:creator>Romo Fedoroff</dc:creator>
    <dc:date>2026-11-03T19:01:00Z</dc:date>
  </entry>
  <entry>
    <title>Краткий обзор pgloader: инструмент для миграции баз данных</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21326265" />
    <author>
      <name>Никита Рогаленко</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21326265</id>
    <updated>2026-10-31T21:02:15Z</updated>
    <published>2026-10-31T21:02:00Z</published>
    <summary type="html">&lt;p style="text-align: justify;"&gt;Во время крупных обновлений инфраструктуры системы, при необходимости значительных архитектурных изменений и в других неприятных ситуациях зачастую возникает потребность в серьезных правках структуры используемой базы данных. В таком случае полезной может оказаться команда pgloader. Утилита pgloader представляет собой мощный специализированный инструмент с открытым исходным кодом, предназначенный для автоматизированной миграции и загрузки данных в PostgreSQL из различных источников. Главная ценность этого инструмента заключается в полной автоматизации процесса. Pgloader умеет самостоятельно считывать схему данных источника, транслировать типы данных в совместимые с PostgreSQL, создавать таблицы, индексы и переносить саму информацию за одну команду.&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;Что же умеет pgloader и в чем состоит его польза? Перечислим несколько основных достоинств:&lt;/p&gt;

&lt;ul&gt;
	&lt;li style="text-align: justify;"&gt;Мультиплатформенный импорт: утилита поддерживает миграцию «на лету» из MySQL, MS SQL, SQLite, а также загрузку из файлов формата CSV (и многих других)&lt;/li&gt;
	&lt;li style="text-align: justify;"&gt;Автоматическое преобразование типов: утилита сама сопоставляет типы данных (например, datetime из MySQL преобразует в timestamp для Postgres)&lt;/li&gt;
	&lt;li style="text-align: justify;"&gt;Умная обработка ошибок: вместо падения при первой же битой строке, pgloader отправляет некорректные данные в отдельный reject-лог, продолжая загрузку остальных записей&lt;/li&gt;
	&lt;li style="text-align: justify;"&gt;Высокая скорость: использует встроенный протокол PostgreSQL COPY для потоковой передачи больших объемов данных без накладных расходов на парсинг каждого SQL-запроса&lt;/li&gt;
	&lt;li style="text-align: justify;"&gt;Возможность настраивать правила трансформации (например, замену пустых строк на NULL или изменение кодировки).&lt;/li&gt;
&lt;/ul&gt;

&lt;p style="text-align: justify;"&gt;Кроме всего перечисленного, как и у любого инструмента, у pgloader есть не только плюсы, но и свои недостатки. Так, при обработке огромных баз данных или сложных связей он может быть крайне требователен к оперативной памяти, а&amp;nbsp;стэк-трейс на Common Lisp, на котором написана утилита, бывает трудно прочитать разработчику без специфического опыта. Кроме того, при всех возможностях кастомизации работа с DDL ограничена, поэтому если нужна тонкая настройка внешних ключей или специфических индексов, схему лучше подготовить в Postgres заранее, а pgloader использовать только для данных (data only).&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;Сама же команда pgloader запускается с помощью файла конфигурации (обычно с расширением .load). Перед примером классического файла для миграции перечислим некоторые важные флаги (добавляются при вызове команды) и параметры конфигурации в самом файле:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;--version: показать установленную версию&lt;/li&gt;
	&lt;li&gt;-v, --verbose: выводить подробный лог работы (полезно для отслеживания прогресса)&lt;/li&gt;
	&lt;li&gt;-d, --debug: включить режим отладки&lt;/li&gt;
	&lt;li&gt;workers = X: количество одновременных потоков для чтения данных из источника&lt;/li&gt;
	&lt;li&gt;concurrency = X:&amp;nbsp; количество потоков для одновременной записи в PostgreSQL&lt;/li&gt;
	&lt;li&gt;include drop:&amp;nbsp; удалять существующие таблицы в Postgres перед началом импорта&lt;/li&gt;
	&lt;li&gt;data only:&amp;nbsp; импорта только содержимого (схема должна быть уже создана)&lt;/li&gt;
	&lt;li&gt;schema only: перенос только структуры таблиц без самих данных&lt;/li&gt;
&lt;/ul&gt;

&lt;p style="text-align: justify;"&gt;Запуск скрипта осуществляется через простой вызов &lt;code&gt;pgloader migrate.load&lt;/code&gt;​​​​​​​. Приведем пример файла migrate.load с комментариями:&lt;/p&gt;

&lt;pre class="brush:bash;"&gt;
/* 
  Указываем тип миграции. В данном случае мы переносим всю базу данных (DATABASE),
  включая схемы, таблицы, индексы и данные.
*/
LOAD DATABASE
     -- Источник: строка подключения к исходной базе данных MySQL
     FROM mysql://root:password@localhost/my_old_db
     
     -- Цель: строка подключения к целевой базе данных PostgreSQL
     INTO postgresql://postgres:password@localhost/my_new_db

 /* 
   Секция WITH задает глобальные параметры поведения pgloader 
 */
 WITH include drop,      -- Удалять таблицы в Postgres, если они там уже существуют
      create tables,     -- Автоматически создавать структуры таблиц в Postgres
      create indexes,    -- Автоматически переносить и создавать индексы
      reset sequences,   -- Сбросить и выставить автоинкременты (последовательности) в актуальные значения
      workers = 4,       -- Использовать 4 параллельных потока для чтения данных из MySQL
      concurrency = 2    -- Использовать 2 параллельных потока для записи данных в PostgreSQL

  /* 
    Секция SET позволяет задать специфические настройки для сессии СУБД.
    В данном случае увеличиваем таймауты MySQL, чтобы соединение не оборвалось на больших таблицах.
  */
  SET MySQL parameters
      net_read_timeout  = '120',
      net_write_timeout = '120'

 /* 
   Секция CAST - это правила трансформации типов данных (из MySQL в Postgres)
 */
 CAST type datetime to timestamp drop default drop not null,
      -- Превращаем datetime в timestamp, сбрасывая дефолтные значения и ограничение NOT NULL
      
      type tinyint to boolean using tinyint-to-boolean
      -- Конвертируем тип tinyint в логический тип (boolean) с помощью встроенной функции

 /* 
   Секция BEFORE LOAD DO позволяет выполнить любые SQL-команды 
   в целевой базе PostgreSQL строго ДО начала миграции.
 */
 BEFORE LOAD DO
   $$ drop schema if exists mysql cascade; $$; 
   -- Удаляем старую схему mysql (если она осталась от прошлых тестов), чтобы избежать конфликтов
&lt;/pre&gt;

&lt;p style="text-align: justify;"&gt;В результате этих манипуляций после запуска pgloader командой выше мы получим вывод в стиле:&lt;/p&gt;

&lt;pre class="brush:plain;"&gt;
                                 table name       read   imported     errors      total time
-------------------------------------------  ---------  ---------  ---------  --------------
                            before load do...        1          1          0          0.015s
                             fetch meta data        42         42          0          0.218s
-------------------------------------------  ---------  ---------  ---------  --------------
                             mysql.users          5000       5000          0          0.452s
                             mysql.orders        12500      12498          2          1.120s
                        index build &amp;amp; phrs          --         --          0          0.340s
-------------------------------------------  ---------  ---------  ---------  --------------
                    reset sequences (auto)           2          2          0          0.042s
-------------------------------------------  ---------  ---------  ---------  --------------
                          Total import time      17542      17540          2          2.187s
&lt;/pre&gt;

&lt;p style="text-align: justify;"&gt;По сводной таблице сразу видно, как прошла миграция. Колонка table name показывает этапы работы и имена перенесенных таблиц (с указанием схемы), read - сколько строк pgloader смог прочитать из MySQL, imported - сколько строк успешно записалось в PostgreSQL, errors - количество «битых» строк, которые Postgres отказался принимать (например, из-за нарушения уникальности или невалидных данных), total time - время, затраченное на каждую таблицу и операцию. Если количество ошибок больше нуля, то стоит изучить файлы&amp;nbsp;&lt;code&gt;*.reject&lt;/code&gt; и&amp;nbsp;&lt;code&gt;*.log&lt;/code&gt;, которые содержат сами строки, которые не удалось вставить, и описание конкретной ошибки соответственно. Найденные ошибки можно исправить самостоятельно и догрузить только пропущенные данные.&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;После того, как утилита отработает, в&amp;nbsp;MySQL (источник) ничего не изменится, т.к. pgloader использует режим Read-Only для источника. Никакие данные не удалятся и не модифицируются. В PostgreSQL (Цель) сначала выполнится блок BEFORE LOAD DO: если в Postgres уже была схема с именем mysql, она полностью удалится со всеми таблицами (CASCADE). Затем последовательно создадутся - новые таблицы со структурой, аналогичной MySQL (но с адаптированными типами данных: например, tinyint превратится в boolean), все строки из MySQL, индексы и внешние ключи. Значения автоинкремента (sequences) также обновятся до актуального максимума, чтобы новые записи в Postgres начинались с правильного ID. Подобным образом, мы получим полностью готовую смигрированную новую базу с преобразованными старыми данными.&lt;/p&gt;</summary>
    <dc:creator>Никита Рогаленко</dc:creator>
    <dc:date>2026-10-31T21:02:00Z</dc:date>
  </entry>
  <entry>
    <title>Преждевременная спецификация при работе с AI-агентами</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21317573" />
    <author>
      <name>Maxim Kalabukhov</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21317573</id>
    <updated>2026-10-09T12:48:57Z</updated>
    <published>2026-10-09T12:40:00Z</published>
    <summary type="html">&lt;article lang="ru"&gt;
&lt;p&gt;Всем привет! Сегодня хочу поговорить о преждевременной спецификации при работе с ИИ-агентами - ситуации, когда мы подробно объясняем, как написать код, но упускаем, какую задачу он должен решать.&lt;/p&gt;

&lt;p&gt;Пример запроса: &lt;em&gt;Добавь параметр &lt;code&gt;integration.enabled&lt;/code&gt;. В начале метода &lt;code&gt;send()&lt;/code&gt; проверяй его значение: если &lt;code&gt;false&lt;/code&gt;, сразу делай &lt;code&gt;return&lt;/code&gt;.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Такой запрос выглядит хорошей постановкой задачи. Есть название настройки, конкретный метод и понятная логика. Агенту удобно приступать к работе: найти нужный класс, добавить проверку, написать тест. Но какую проблему должен решить этот код?&amp;nbsp;Возможно, нужно временно приостановить отправку данных. Возможно, запретить обращения к внешней системе на тестовом стенде. А возможно, приложение должно работать у клиентов, которые вообще не подключали интеграцию: без её адреса, учётных данных и доступности по сети.&amp;nbsp;За одной инструкцией могут стоять разные требования. Пока исходная проблема остаётся только в голове разработчика, агенту трудно проверить, подходит ли предложенный механизм.&lt;/p&gt;

&lt;p&gt;Назовём это &lt;strong&gt;преждевременной спецификацией&lt;/strong&gt;: мы указываем функции, библиотеки и порядок действий раньше, чем объясняем цель задачи.&amp;nbsp;&lt;/p&gt;

&lt;p&gt;Разработчику легко попасть в эту ситуацию. Мы привыкли быстро переходить от проблемы к технической гипотезе и по итогу в запрос агенту попадает последний шаг рассуждения. Причины, предположения и ожидаемый результат остаются за его пределами.&lt;/p&gt;

&lt;p&gt;Представим, что интеграция нужна только части клиентов. Для остальных приложение должно запускаться и выполнять основные функции без её настроек.&amp;nbsp;Проверка в &lt;code&gt;send()&lt;/code&gt; запрещает отправку, но компонент интеграции по-прежнему может создаваться при запуске приложения. Его конфигурация требует URL и учётные данные. Без них приложение падает ещё до первого вызова &lt;code&gt;send()&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Агент способен аккуратно реализовать проверку флага, а исходная проблема сохранится.&amp;nbsp;Более того, тест тоже может оказаться привязан к выбранному механизму. Он подтвердит, что при выключенном флаге метод отправки не вызывается. Но ничего не скажет о запуске приложения без настроек интеграции. Получится корректная реализация инструкции без подтверждения, что задача решена.&lt;/p&gt;

&lt;p&gt;Теперь сформулируем поручение иначе:&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Интеграция нужна только части клиентов. При &lt;code&gt;integration.enabled=false&lt;/code&gt; приложение должно запускаться и выполнять основные функции без адреса и учётных данных внешней системы. Обращений к ней быть не должно, в том числе из фоновых задач.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Я предполагаю, что потребуется проверка флага, но место и способ отключения нужно определить по коду. Проверь создание компонентов и точки обращения к интеграции. Подтверди результат запуском с выключенной интеграцией и без её настроек.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;У агента появляется основание для оценки решения. Он знает желаемое поведение и сценарий проверки. Предложение про флаг сохраняется, но его статус понятен: это идея, которую нужно проверить.&amp;nbsp;Теперь агенту можно обнаружить, что отключать требуется создание компонентов, например через &lt;code&gt;@ConditionalOnProperty&lt;/code&gt; в Spring. Или что отдельного внимания требуют фоновые задачи. Это даёт агенту контекст, позволяющий заметить расхождение между механизмом и целью.&lt;/p&gt;

&lt;p&gt;Практически полезно разделять в постановке три вещи:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;&lt;strong&gt;Цель:&lt;/strong&gt; какое наблюдаемое поведение должно измениться.&lt;/li&gt;
	&lt;li&gt;&lt;strong&gt;Ограничения:&lt;/strong&gt; какие условия действительно обязательны и почему.&lt;/li&gt;
	&lt;li&gt;&lt;strong&gt;Гипотеза реализации:&lt;/strong&gt; какой способ решения кажется подходящим.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Конкретная библиотека или порядок вызовов вполне могут быть обязательными. Возможно, решение уже исследовали и согласовали в команде. Эти детали стоит передавать вместе с причинами. Тогда агенту проще понять, где допустимо предложить альтернативу, а где требуется соблюдать принятое решение.&amp;nbsp;Для небольшой задачи достаточно нескольких предложений. Не нужно превращать каждый запрос в развёрнутое ТЗ. Нужно сохранить связь между проблемой и действиями, которые мы поручаем выполнить.&lt;/p&gt;

&lt;p&gt;Перед отправкой запроса можно сделать простую проверку: мысленно убрать названия библиотек, функций и последовательность вызовов. Останется ли понятно, чего нужно добиться и как определить, что задача решена?&amp;nbsp;Если нет, стоит дописать цель. Даже когда план уже готов.&lt;/p&gt;
&lt;/article&gt;</summary>
    <dc:creator>Maxim Kalabukhov</dc:creator>
    <dc:date>2026-10-09T12:40:00Z</dc:date>
  </entry>
  <entry>
    <title>AI-тестирование интерфейсов: Когда агент ходит по сайту вместо вас</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21315536" />
    <author>
      <name>Алексей Кондратьев</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21315536</id>
    <updated>2026-10-07T08:40:00Z</updated>
    <published>2026-10-07T07:54:00Z</published>
    <summary type="html">&lt;p&gt;Любой цифровой продукт — это живой организм, который растет и усложняется. И чем сложнее его устройство, тем выше цена ошибки: незамеченный баг — это потерянный пользователь, упавшая конверсия и подорванное доверие. Поэтому тестирование давно перестало быть финальным этапом перед релизом и превратилось в непрерывный процесс, сопровождающий продукт на всём его жизненном цикле.&amp;nbsp;&lt;/p&gt;

&lt;p&gt;Вы закончили верстку нового интерфейса, задеплоили его, и теперь нужно проверить, что ничего не сломалось. Раньше это означало либо ручной прогон по всем страницам, либо поддержку хрупких Selenium-скриптов, которые ломаются от смены одного CSS-класса. Но в 2026 году появился третий путь: вы запускаете AI-агента, который открывает браузер, «ходит» по интерфейсу как живой пользователь, находит баги и присылает структурированный отчет.&lt;/p&gt;

&lt;p&gt;Звучит как фантастика? Уже нет.&lt;/p&gt;

&lt;h2&gt;Что такое AI-тестирование интерфейсов&lt;/h2&gt;

&lt;p&gt;AI-тестирование интерфейсов — это подход, при котором автономный агент на базе большой языковой модели (LLM) получает доступ к реальному браузеру и выполняет задачи по проверке веб-приложения. Вместо того чтобы писать жёсткие селекторы вроде &lt;code&gt;page.click('#submit-btn &amp;gt; .primary')&lt;/code&gt;, вы говорите агенту на естественном языке: «Проверь, что форма логина работает корректно при вводе неверного пароля» .&lt;/p&gt;

&lt;p&gt;Ключевое отличие от классической автоматизации — агент не следует заранее написанному сценарию. Он рассуждает. Он видит страницу, анализирует её состояние, принимает решение о следующем действии, выполняет его и снова оценивает результат. Это цикл «восприятие — решение — действие — проверка», который повторяется до достижения цели или обнаружения проблемы.&lt;/p&gt;

&lt;h2&gt;Как это работает технически: Playwright + MCP&lt;/h2&gt;

&lt;p&gt;Техническая основа большинства современных AI-тестировщиков — это комбинация Playwright(как «руки» и «глаза» агента) и Model Context Protocol (MCP) (как «нервная система», передающая информацию между браузером и LLM).&lt;/p&gt;

&lt;p&gt;Playwright MCP-сервер — это отдельный процесс, который предоставляет AI-ассистенту доступ к живой браузерной сессии. Агент может инспектировать реальный DOM, кликать по элементам, наблюдать за навигацией и генерировать точные тесты на основе того, что он увидел.&lt;/p&gt;

&lt;p&gt;Представьте, что вы даёте AI не просто скриншот страницы, а «живой» доступ к браузеру. Он может:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Перейти на нужный URL&lt;/li&gt;
	&lt;li&gt;Изучить структуру страницы (какие элементы есть, какие у них ARIA-метки, где iframe-границы)&lt;/li&gt;
	&lt;li&gt;Кликнуть по кнопке и посмотреть, что произошло&lt;/li&gt;
	&lt;li&gt;Ввести текст в поле и проверить, появилась ли валидация&lt;/li&gt;
	&lt;li&gt;Сделать скриншот и проанализировать визуальное состояние&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;И всё это — без открытия DevTools вручную.&lt;/p&gt;

&lt;h2&gt;Что именно находит AI-агент&lt;/h2&gt;

&lt;p&gt;Спектр задач, которые решают современные AI-тестировщики, впечатляет.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Функциональные баги. &lt;/strong&gt;Агент может проверить, что форма отправляется, кнопка нажимается, ссылка ведёт туда, куда должна. Он может пройти пользовательский сценарий от начала до конца: залогиниться, добавить товар в корзину, оформить заказ — и проверить, что на каждом шаге всё работает.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Сломанные ссылки и неработающие формы. &lt;/strong&gt;Агент обходит страницы, кликает по ссылкам, заполняет поля и проверяет, что нет 404-х и что валидация работает корректно.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Визуальные баги.&lt;/strong&gt; Это отдельная большая тема. Инструменты вроде Frontguard или cypress-visual-eval используют AI для сравнения скриншотов с эталоном. Если пиксели разошлись, AI анализирует разницу и говорит: «Это регрессия — кнопка уехала вправо» или «Это ожидаемое изменение — вы добавили новый блок».&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;UX/UI-критика.&lt;/strong&gt; Некоторые агенты могут не просто найти баг, но и оценить интерфейс с точки зрения пользователя: «Контраст текста недостаточен», «Навигация неинтуитивна», «Слишком много визуального шума».&lt;/p&gt;

&lt;h2&gt;Инструменты, которые уже работают&lt;/h2&gt;

&lt;p&gt;Рынок AI-тестирования интерфейсов в 2026 году уже достаточно зрел, чтобы предлагать готовые решения.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Playwright MCP&lt;/strong&gt; — это базовый строительный блок. Вы устанавливаете MCP-сервер, подключаете его к вашему AI-ассистенту (GitHub Copilot, Claude, Cursor), и агент получает доступ к браузеру. Дальше вы просто описываете, что нужно проверить, и AI генерирует точный тест, основанный на реальной структуре страницы.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;ai-ui-testing&lt;/strong&gt; — это Python-фреймворк, который решает две главные боли традиционной автоматизации: хрупкость локаторов и сложность анализа падений. Он умеет генерировать локаторы по естественному описанию («кнопка логина»), автоматически исправлять их при изменении страницы и давать AI-анализ причин падения теста .&lt;br /&gt;
&lt;strong&gt;qa-agent&lt;/strong&gt; — автономный агент, который может работать в двух режимах: «focused» (проверка указанных URL) и «explore» (краулинг сайта с автоматическим обнаружением страниц). Он поддерживает параллельный запуск нескольких браузеров, аутентификацию и экспорт отчётов в Markdown, JSON или PDF.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;SERA Browser Agent&lt;/strong&gt; — production-quality агент с детекцией CAPTCHA, изоляцией сессий и возможностью «human takeover»: если агент застрял, человек может перехватить управление браузером в реальном времени.&lt;/p&gt;

&lt;h2&gt;Ограничения и честный разговор&lt;/h2&gt;

&lt;p&gt;Было бы неправильно рисовать только радужную картину. AI-тестирование интерфейсов 2026 года — это мощный инструмент, но не серебряная пуля.&lt;/p&gt;

&lt;p&gt;Стоимость. Каждый шаг агента — это вызов LLM, а значит, токены и деньги. Для больших сайтов с сотнями страниц затраты могут быть существенными. Исследования показывают, что гибридный подход (AI для исследования, скомпилированный скрипт для повторяющихся прогонов) снижает стоимость на 98% по сравнению с чистым агентным подходом.&lt;/p&gt;

&lt;p&gt;Недетерминированность. AI-агент может вести себя по-разному при одинаковых входных данных. Он может «передумать», пойти по другому пути, найти другой элемент. Для регрессионного тестирования, где важна воспроизводимость, это проблема. Гибридные подходы решают её, компилируя успешный путь агента в детерминированный скрипт.&lt;/p&gt;

&lt;p&gt;Галлюцинации и ложные срабатывания. Агент может «увидеть» баг там, где его нет, или, наоборот, пропустить реальную проблему. Особенно это касается визуальных тестов: AI-классификатор может неверно оценить, является ли изменение пикселей регрессией или ожидаемым обновлением контента.&lt;/p&gt;

&lt;p&gt;Сложные сценарии. Enterprise-приложения с iframe, SSO, динамической загрузкой данных (30-60 секунд на подгрузку Dataverse-галереи) — это всё ещё вызов даже для продвинутых агентов. Им нужна помощь в виде таймингов, обхода iframe-границ и обработки состояний загрузки.&lt;/p&gt;

&lt;h2&gt;Практический workflow: как это выглядит в жизни&lt;/h2&gt;

&lt;p&gt;Вот как выглядит типичный рабочий процесс с AI-тестированием сегодня.&lt;/p&gt;

&lt;p&gt;Вы запускаете приложение на локальном сервере или стейджинге. Подключаете AI-ассистента (например, Claude через MCP-сервер) к браузерной сессии. Пишете запрос: «Проверь, что регистрация работает: открой страницу, заполни форму с новым email, проверь, что пришло письмо с подтверждением, и что после клика по ссылке пользователь попадает в личный кабинет».&lt;/p&gt;

&lt;p&gt;Агент начинает работу. Он находит форму, заполняет поля, кликает «Отправить». Он проверяет состояние после каждого шага. Если что-то пошло не так — он пытается понять причину и либо исправляется, либо фиксирует баг в отчёте. В конце вы получаете структурированный документ: что проверялось, что сработало, что сломалось, скриншоты проблемных мест, предложения по исправлению.&lt;/p&gt;

&lt;h2&gt;Заключение&lt;/h2&gt;

&lt;p&gt;AI-тестирование интерфейсов перестало быть экспериментом. Это рабочий инструмент, который уже сегодня используется в production-пайплайнах. Он не заменяет традиционную автоматизацию полностью, но занимает свою нишу: исследовательское тестирование, проверка новых фич, визуальный регресс, генерация тестовых сценариев.&lt;/p&gt;

&lt;p&gt;Главное преимущество — снижение порога входа. Вам больше не нужно быть экспертом по Playwright, чтобы написать тест. Достаточно описать, что вы хотите проверить, и агент сделает остальное. Это не значит, что можно расслабиться: за агентом всё равно нужно присматривать, проверять его выводы и не давать ему слишком много свободы на критических операциях. Но это уже совсем другой уровень скорости и удобства по сравнению с тем, что было ещё пару лет назад.&lt;/p&gt;</summary>
    <dc:creator>Алексей Кондратьев</dc:creator>
    <dc:date>2026-10-07T07:54:00Z</dc:date>
  </entry>
  <entry>
    <title>Введение в архитектуру ПО. Часть 3: Объектно-ориентированное программирование и власть над зависимостями</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21315546" />
    <author>
      <name>Romo Fedoroff</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21315546</id>
    <updated>2026-10-07T12:24:06Z</updated>
    <published>2026-10-06T12:06:00Z</published>
    <summary type="html">&lt;style type="text/css"&gt;article p {
font-size:11pt;
font-family:Verdana, sans-serif;
text-align:justify;
color:#6a6a6a;
}

article img {
width: 90%;
}

article li {
 font-size:11pt;   
}

.centered {
text-align:center;
}


article .portlet-msg-info {
color: #232323;
background-color: #f9f9f9;
border-style: dashed;
border-color: #232323;
}
&lt;/style&gt;
&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Введение&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;В конце предыдущей части мы обозначили тему продолжения: вторая парадигма - объектно-ориентированное программирование. Чем оно на самом деле является, почему полиморфизм оказался главным архитектурным изобретением за пятьдесят лет и как с его помощью развернуть направление зависимостей между модулями в нужную сторону - давайте об этом и поговорим.&lt;/p&gt;

&lt;p&gt;Напомним исходную мысль. Мы приняли, что каждая парадигма программирования не расширяет возможности разработчика, а сознательно их ограничивает. Структурное программирование забрало неограниченные переходы, а взамен дало возможность разбирать программу на части и проверять каждую отдельно. Объектно-ориентированное забирает свободное обращение с указателями на функции. Что оно даёт взамен - главный вопрос этой статьи.&lt;/p&gt;

&lt;p&gt;Начнём издалека, с вещи настолько обыденной, что о ней обычно не задумываются: со строки импорта в начале файла.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Зависимость исходного кода&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Представим интернет-магазин. В нём есть модуль, принимающий заказ: он проверяет корзину, применяет скидки, считает налог, добавляет доставку и сохраняет результат. Назовём его ordering. И есть модуль работы с базой данных - persistence, где живёт класс PostgresOrderRepository.&lt;/p&gt;

&lt;p&gt;Чтобы сохранить заказ, ordering обращается к persistence. А чтобы обратиться, он обязан объявить об этом компилятору:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
import persistence.PostgresOrderRepository&lt;/pre&gt;

&lt;p&gt;Строка выглядит технической мелочью. На деле она закрепляет отношение между двумя частями системы, и отношение это прочнее, чем кажется.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Для тех, кто только начинает:&lt;/strong&gt; зависимость исходного кода - это ответ на вопрос «что ещё требуется иметь под рукой, чтобы этот файл скомпилировался». Строка import сообщает компилятору: здесь используется чужой код, найди его описание. Пока такая строка есть, два модуля связаны - собрать первый без второго не получится.&lt;/p&gt;

&lt;p&gt;Разберём, что эта связь означает для модуля ordering. Каждый пункт в перечне ниже - отдельное ограничение, и с каждым придётся жить.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Его нельзя собрать в отрыве от хранилища&lt;/strong&gt;. Компилятору понадобится persistence, тому - драйвер базы данных, драйверу - его собственные зависимости. Правила расчёта заказа оказываются на вершине цепочки, в которой они не нуждаются.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Его нельзя проверить без базы данных&lt;/strong&gt;. Чтобы выполнить тест на расчёт скидки, придётся поднять настоящую базу, накатить схему, подготовить записи. Логика расчёта при этом ничего не знает ни про схему, ни про записи - ей нужны три числа и правило.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Его тяжело передать другой команде&lt;/strong&gt;. Вместе с модулем уедет вся цепочка зависимостей. Договориться о границе ответственности не выйдет: граница размазана.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Замена хранилища задевает расчёт заказа&lt;/strong&gt;. Переход на другую базу означает правки в файлах, где написаны правила начисления скидок. Сами правила при этом не меняются ни на букву.&lt;/p&gt;

&lt;p&gt;Обратим внимание на общее у всех четырёх пунктов. Ни одно из ограничений не следует из того, что модуль считает. Логика скидок, налогов и доставки работала бы в пустоте - ей не нужно ни хранилище, ни сеть, ни файловая система. Ограничения возникли из отношения, а не из существа дела.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Строка импорта - это симптом, а не болезнь&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Здесь нужно остановиться и предупредить недоразумение, в которое легко впасть. Может показаться, что всё упирается в одну строку и дело решается её удалением: получать репозиторий через параметр, имени класса не упоминать. Это заблуждение, и довольно распространённое.&lt;/p&gt;

&lt;p&gt;Строка импорта - форма, в которой зависимость становится видимой и проверяемой компилятором. Но сама зависимость заключается не в строке, а в знании: модуль ordering знает, что существует класс PostgresOrderRepository, знает его имя, знает набор его методов и их сигнатуры, рассчитывает на определённое поведение. Уберите строку, оставив знание, - и ничего не изменится. Код по-прежнему нельзя собрать отдельно, потому что где-то в нём упомянут тип из чужого модуля.&lt;/p&gt;

&lt;p&gt;Настоящий вопрос звучит иначе: что именно модуль ordering обязан знать о внешнем мире, чтобы делать свою работу? Ответ: он должен знать, что заказ где-то сохраняется и откуда-то достаётся. Для расчёта этого хватает. А вот знание о том, что хранилище представляет собой реляционную базу, что обращение к ней идёт через драйвер и что класс называется PostgresOrderRepository, для расчёта заказа избыточно. Именно это избыточное знание и создаёт все четыре ограничения.&lt;/p&gt;

&lt;p&gt;Такая формулировка задачи - отделить необходимое знание от избыточного - приведёт нас к решению. Но прежде стоит разобраться с тем, что направление зависимости вообще поддаётся выбору.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Почему направление кажется предопределённым&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Строку импорта приходится писать потому, что ordering вызывает persistence. Чтобы вызвать чужой код, надо на него сослаться - иначе компилятор не найдёт, что вызывать.&lt;/p&gt;

&lt;p&gt;Отсюда делается естественный вывод. Кто кого вызывает, диктует задача: расчёт заказа сохраняет данные, а не данные рассчитывают заказ. Если направление зависимости повторяет направление вызова, значит, и оно продиктовано задачей. Выбора у архитектора нет.&lt;/p&gt;

&lt;p&gt;Вывод этот неверен, и в его опровержении состоит содержание статьи. Направление вызова действительно диктуется задачей. Направление зависимости - нет. Объектно-ориентированные языки дают механизм, позволяющий развернуть ссылку в исходном коде, не трогая того, кто кого вызывает во время работы программы.&lt;/p&gt;

&lt;p&gt;Прежде чем показать механизм, придётся разобраться с определениями. Вопрос «что такое объектно-ориентированное программирование» имеет несколько распространённых ответов, и ни один из них к нашей задаче не подводит.&lt;/p&gt;

&lt;h2&gt;Три ответа на вопрос, что такое ООП&lt;/h2&gt;

&lt;h3&gt;Ответ первый: объединение данных и функций&lt;/h3&gt;

&lt;p&gt;Формулировка встречается чаще других. Данные и работающие с ними функции собираются в одном месте, под одной крышей - вот и объект.&lt;/p&gt;

&lt;p&gt;Проверим её на прочность. Определение подразумевает, что вызов o.f() принципиально отличается от вызова f(o). Отличие есть: в первом случае объект передаётся неявно, в роли получателя сообщения, во втором - явно, первым аргументом. Но это отличие в записи, а не в существе. Передавать структуру первым аргументом в функцию, которая с ней работает, программисты начали задолго до появления объектно-ориентированных языков, и никакой новой парадигмы из этого не выросло.&lt;/p&gt;

&lt;p&gt;Здесь уместно возражение, и его стоит разобрать, а не обойти. Скажут: вызов метода делает кое-что сверх передачи объекта - он выбирает реализацию по фактическому типу. Один и тот же o.f() приведёт к разному коду в зависимости от того, что лежит в o. Возражение справедливо, но доказывает оно другое. Выбором реализации занимается полиморфизм, и к нему мы придём отдельно. Само по себе соседство полей и методов в одном классе такого выбора не создаёт.&lt;/p&gt;

&lt;p&gt;Что до нашей задачи - она от этого определения не сдвигается. Соберите данные и функции хоть в один класс, хоть в десять: ordering по-прежнему упоминает PostgresOrderRepository, и все четыре ограничения остаются в силе.&lt;/p&gt;

&lt;h3&gt;Ответ второй: моделирование реального мира&lt;/h3&gt;

&lt;p&gt;Второй ответ звучит привлекательнее и объясняет меньше. Объекты в программе соответствуют сущностям в предметной области, код становится похож на реальность, реальность понятна - значит, понятен и код.&lt;/p&gt;

&lt;p&gt;Трудность начинается при попытке применить это к чему-то, кроме учебных примеров с животными и фигурами. Что считать соответствием реальному миру для банковской транзакции? Для HTTP-запроса? Для индекса в базе данных или для пула соединений? У этих сущностей нет прообраза вне программы, они порождены самой техникой.&lt;/p&gt;

&lt;p&gt;Допустим даже, что близость к предметной области действительно облегчает понимание - утверждение правдоподобное. Из него всё равно не выводится ни одного решения. Оно не подсказывает, в каком модуле объявить тип, куда направить ссылку, как разделить систему на части. А задача, с которой мы начали, требует именно таких решений.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Для тех, кто только начинает&lt;/strong&gt;: речь не о том, что объектно-ориентированный подход бесполезен. Речь о том, чего мы ждём от определения. Хорошее определение работает как инструмент: узнав его, человек начинает что-то делать иначе. Оба ответа выше ничего в работе не меняют - потому и не удовлетворяют.&lt;/p&gt;

&lt;h3&gt;Ответ третий: три слова&lt;/h3&gt;

&lt;p&gt;Остаётся самый расхожий вариант, знакомый всякому, кто готовился к собеседованию: объектно-ориентированное программирование - это инкапсуляция, наследование и полиморфизм.&lt;/p&gt;

&lt;p&gt;Ответ хорош тем, что называет конкретные вещи, которые можно проверить. Этим и займёмся. К каждому из трёх понятий мы подойдём с одним и тем же вопросом: помогает ли оно убрать из модуля ordering избыточное знание о хранилище.&lt;/p&gt;

&lt;p&gt;Прежде чем начать, стоит сказать пару слов о происхождении этих понятий - история здесь объясняет многое.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Откуда всё взялось&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;В середине шестидесятых годов двое норвежских учёных, Оле-Йохан Даль и Кристен Нюгор, работали в Норвежском вычислительном центре в Осло над языком для имитационного моделирования. Им требовалось описывать системы, состоящие из множества взаимодействующих сущностей - очереди, корабли, порты.&lt;/p&gt;

&lt;p&gt;За основу взяли ALGOL 60 и заметили в нём следующую возможность. Кадр стека, в котором живут локальные переменные вызванной функции, можно разместить не на стеке, а в динамической памяти. Тогда после выхода из функции её локальные переменные не исчезают - они продолжают существовать, и на них можно ссылаться.&lt;/p&gt;

&lt;p&gt;Из этого наблюдения выросли остальные понятия. Функция, размещающая свой кадр в куче, превращается в конструктор. Её локальные переменные - в поля объекта. Вложенные в неё функции - в методы. Язык, построенный на этой идее, получил имя Simula 67; в нём впервые появились классы, объекты, наследование и виртуальные процедуры - то, что мы сегодня называем виртуальными методами. В 2001 году Даль и Нюгор получили за эту работу премию Тьюринга.&lt;/p&gt;

&lt;p&gt;Обратим внимание на последовательность. Сначала появился механизм - объект, переживающий вызов. Потом вокруг него выстроились понятия. А слова, которыми этот подход принято объяснять сегодня, появились ещё позже и описывают не столько механизм, сколько впечатление от него. Отчасти поэтому они и объясняют так мало.&lt;/p&gt;

&lt;h3&gt;&lt;strong&gt;Инкапсуляция&lt;/strong&gt;&lt;/h3&gt;

&lt;p&gt;Инкапсуляция очерчивает границу вокруг группы данных и функций. Снаружи видна лишь часть функций, данные скрыты. В объектно-ориентированных языках это выглядит привычно: приватные поля, публичные методы.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Решает ли она нашу задачу&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Нет, и причина лежит на поверхности. Пометьте все поля PostgresOrderRepository как приватные, спрячьте половину методов - строка импорта в модуле ordering останется на месте. Инкапсуляция управляет тем, что видно внутри класса при его использовании. О том, кто и откуда вправе на класс сослаться, она не говорит ничего.&lt;/p&gt;

&lt;p&gt;Разница существенная, и к ней стоит присмотреться. Инкапсуляция - средство от неосторожного обращения: она не даёт постороннему коду залезть в чужие потроха и завязаться на детали, которые автор менять не обещал. Задача достойная, но другая. Нам нужно не ограничить обращение к классу, а избавиться от обязанности его знать.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Неудобная история&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Проверив инкапсуляцию на нашей задаче, стоит задержаться и отметить обстоятельство, которое обычно упускают: объектно-ориентированные языки инкапсуляцию не изобрели. В языке C она была устроена так, что скрывала больше.&lt;/p&gt;

&lt;p&gt;Взглянем на заголовочный файл. Это всё, что видит пользователь модуля:&lt;/p&gt;

&lt;pre class="brush:cpp;"&gt;
/* point.h */
struct Point;                                  /* объявлена, но не описана */
struct Point* makePoint(double x, double y);
double distance(struct Point* p1, struct Point* p2);&lt;/pre&gt;

&lt;p&gt;Устройство структуры живёт в отдельном файле, который наружу не выходит:&lt;/p&gt;

&lt;pre class="brush:cpp;"&gt;
/* point.c */
#include "point.h"
#include &amp;lt;stdlib.h&amp;gt;
#include &amp;lt;math.h&amp;gt;

struct Point {
    double x, y;
};

struct Point* makePoint(double x, double y) {
    struct Point* p = malloc(sizeof(struct Point));
    p-&amp;gt;x = x;
    p-&amp;gt;y = y;
    return p;
}

double distance(struct Point* p1, struct Point* p2) {
    double dx = p1-&amp;gt;x - p2-&amp;gt;x;
    double dy = p1-&amp;gt;y - p2-&amp;gt;y;
    return sqrt(dx*dx + dy*dy);
}&lt;/pre&gt;

&lt;p&gt;&lt;strong&gt;Для тех, кто только начинает&lt;/strong&gt;: пример на старом языке приведён ради особенности, которой в Java, C# и Kotlin нет, - физического разделения объявления и реализации на два разных файла.&amp;nbsp;&lt;/p&gt;

&lt;p&gt;Разберём, в чём здесь сила. Пользователь point.h не только не обратится к полям x и y - он не знает об их существовании. Структура объявлена, но не определена; компилятор знает, что такой тип есть, и не знает, из чего он состоит. Работа с ним идёт только через указатель.&lt;/p&gt;

&lt;p&gt;Отсюда следует свойство, в Java, C# и Kotlin недостижимое. Переименуйте поля, добавьте третье, смените типы, поменяйте порядок - вызывающие модули не потребуют перекомпиляции. Достаточно пересобрать файл реализации и выполнить сборку заново.&lt;/p&gt;

&lt;p&gt;Проверяется это за несколько минут, и опыт стоит повторить. Соберите объектный файл вызывающего модуля и запомните его контрольную сумму. Затем перепишите структуру до неузнаваемости - переименуйте оба поля, добавьте ещё два, смените double на float. Пересоберите только файл реализации и слинкуйте программу со старым, нетронутым объектным файлом вызывающего модуля. Программа работает, контрольная сумма не изменилась. В машинном коде вызывающего модуля нет ни размеров, ни смещений - лишь адреса функций и передача указателей.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Что произошло потом&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;В C++ появились классы, а вместе с ними требование описывать поля в заголовочном файле:&lt;/p&gt;

&lt;pre class="brush:cpp;"&gt;
// point.h
class Point {
public:
    Point(double x, double y);
    double distance(const Point&amp;amp; p) const;
private:
    double x;       // теперь поля видны всем, кто подключит заголовок
    double y;
};&lt;/pre&gt;

&lt;p&gt;Компилятор по-прежнему запрещает обращаться к x и y извне. Но они написаны в файле, который читают все клиенты, и переименование поля заставит пересобрать каждого из них. Сокрытие, которое в C было полным, стало частичным: имена видны, прямой доступ закрыт.&lt;/p&gt;

&lt;p&gt;Справедливости ради: приём обхода существует и называется pimpl. В заголовке остаётся объявление вложенной структуры и указатель на неё, а поля уезжают в файл реализации. Сокрытие восстанавливается в прежнем объёме. Платить за это приходится дополнительным выделением памяти при создании объекта и потерей встраивания при вызовах. В C инкапсуляция получалась сама собой из устройства языка; в C++ её приходится выстраивать осознанно и не бесплатно.&lt;/p&gt;

&lt;p&gt;Java, C# и Kotlin отменили разделение на объявление и реализацию вовсе - класс описывается в одном файле целиком. Приватное поле держится на обещании компилятора, а на виртуальной машине Java вызов setAccessible(true) снимает это обещание в три строки.&lt;/p&gt;

&lt;p&gt;Вывод получается неожиданным для привычной картины: средства языка инкапсуляцию скорее ослабили. Держится она не столько на языке, сколько на договорённостях внутри команды - на согласии не обходить ограничение, которое обойти технически несложно.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Где инкапсуляция всё-таки работает&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Из сказанного не следует, что она не нужна. Следует другое: искать её стоит не на уровне класса, а на уровне модуля. И вот там она работает по-настоящему.&lt;/p&gt;

&lt;p&gt;Граница, способная удержать, проходит по единице сборки. В Kotlin за это отвечает модификатор internal:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
// модуль billing

// Видно всем, кто подключил модуль
interface InvoiceCalculator {
    fun calculate(order: Order): Invoice
}

// Видно только внутри модуля billing
internal class DefaultInvoiceCalculator(
    private val taxPolicy: TaxPolicy
) : InvoiceCalculator {
    override fun calculate(order: Order): Invoice { /* ... */ }
}&lt;/pre&gt;

&lt;p&gt;Модулем документация Kotlin называет набор файлов, компилируемых вместе: модуль IntelliJ IDEA, проект Maven, исходный набор Gradle. Соседний модуль на DefaultInvoiceCalculator не сошлётся - компилятор не пропустит: за пределами своего набора файлов такого имени для него не существует.&lt;/p&gt;

&lt;p&gt;Сравним два уровня защиты. Приватное поле просит не трогать - и остаётся просьбой, обходимой рефлексией за несколько строк. Отдельный модуль со скрытыми классами не даёт дотянуться, потому что имя класса не входит в публичный интерфейс библиотеки. Первое - соглашение, второе - ограничение. В предыдущей части мы видели, что архитектура строится на ограничениях; здесь это правило подтверждается буквально.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Для специалистов с опытом&lt;/strong&gt;: есть оговорка, о которой в учебниках обычно не пишут. Запрет на обращение к internal-классу живёт на уровне компилятора Kotlin. Документация по совместимости с Java говорит прямо: internal-объявления становятся в Java публичными. Чтобы ими не воспользовались по случайности, компилятор искажает имена internal-членов, однако имена публичных членов internal-класса не искажаются и остаются вызываемыми из Java. Команде, пишущей целиком на Kotlin, границы хватает; в смешанном проекте её подпирают разделением артефактов сборки. В Java похожую роль играют пакетная видимость и, начиная с девятой версии, система модулей с файлом module-info.java, где пакет недоступен снаружи, пока не перечислен в exports.&lt;/p&gt;

&lt;p&gt;Подведём итог: первое из трёх понятий нашу задачу не решило, хотя по дороге и обнаружилось кое-что полезное.&lt;/p&gt;

&lt;h3&gt;Наследование&lt;/h3&gt;

&lt;p&gt;Наследование позволяет объявить один класс через другой, добавив к нему своё. С этой конструкции начинается знакомство почти с каждым объектно-ориентированным языком.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Решает ли оно нашу задачу&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Снова нет, и снова по причине, лежащей на поверхности. От какого бы класса ни наследовался PostgresOrderRepository, модуль ordering обязан его импортировать, чтобы создать экземпляр. Иерархия классов живёт внутри одного модуля и ничего не говорит о границах между модулями.&lt;/p&gt;

&lt;p&gt;Вдобавок наследование приносит с собой отдельную трудность, о которой речь пойдёт ниже. Сначала посмотрим на историю - она объясняет, откуда взялась сама конструкция.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Приём, существовавший до языков&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Нечто похожее на наследование программисты делали и до появления объектно-ориентированных языков, только руками. Приём таков: объявить структуру, первые поля которой в точности повторяют поля другой структуры, в том же порядке:&lt;/p&gt;

&lt;pre class="brush:cpp;"&gt;
struct NamedPoint {
    double x, y;      /* те же два поля, что и в Point, в том же порядке */
    char* name;
};
&lt;/pre&gt;

&lt;p&gt;Раскладка полей в памяти совпадает: первые шестнадцать байт NamedPoint устроены так же, как весь Point. Значит, указатель на NamedPoint можно привести к указателю на Point и передать в функцию, которая о существовании NamedPoint не подозревает:&lt;/p&gt;

&lt;pre class="brush:cpp;"&gt;
struct NamedPoint* origin = makeNamedPoint(0.0, 0.0, "origin");
struct NamedPoint* corner = makeNamedPoint(1.0, 1.0, "upperRight");

printf("distance=%f\n",
       distance((struct Point*) origin, (struct Point*) corner));&lt;/pre&gt;

&lt;p&gt;Программа печатает distance=1.414214 - корень из двух, расстояние между началом координат и точкой (1,1). Функция distance честно прочитала первые два поля и не заметила подмены.&lt;/p&gt;

&lt;p&gt;Примерно так же компиляторы C++ реализуют одиночное наследование: подобъект базового класса размещается в начале производного, и приведение указателя вверх по иерархии не меняет адрес. Оговорка, впрочем, нужна. Раскладку объекта диктует соглашение конкретной платформы, а не стандарт языка. С появлением виртуальных функций в начало объекта встаёт указатель на таблицу методов, и совпадение с простой структурой пропадает.&lt;/p&gt;

&lt;p&gt;Полноценным наследованием такой приём назвать трудно. Приведение типа пишется руками, компилятор ничего не проверяет, перестановка полей ломает программу незаметно - она продолжит считать, но не то. Множественное наследование таким способом не изобразить вовсе: в начале структуры помещается только один чужой набор полей.&lt;/p&gt;

&lt;p&gt;Языки сделали то же самое безопасным. Компилятор проверяет совместимость типов, приведение становится неявным, появляется множественное наследование интерфейсов:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
open class Point(val x: Double, val y: Double)

class NamedPoint(x: Double, y: Double, val name: String) : Point(x, y)
// приведение типов не требуется, компилятор проверит сам&lt;/pre&gt;

&lt;p&gt;Улучшение заметное. Изобретением его назвать сложнее.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Про слово open&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;В примере выше есть деталь, мимо которой легко пройти. Без ключевого слова open перед class Point код не скомпилируется: в Kotlin класс по умолчанию закрыт для наследования, и открывать его нужно явно.&lt;/p&gt;

&lt;p&gt;Решение это не синтаксическое, а архитектурное, и связано оно с темой статьи напрямую. Наследование создаёт между двумя классами связь более жёсткую, чем любой вызов метода. Наследник зависит не только от публичного контракта предка, но и от его внутреннего устройства: какие методы вызывают какие, в каком порядке меняется состояние, что считается инвариантом. В сигнатурах ничего из этого не записано, а значит, и не проверяется.&lt;/p&gt;

&lt;p&gt;Следствие знакомо всякому, кто поддерживал большую иерархию. Правка в базовом классе ломает потомков, невидимых автору правки и порой ему неизвестных. Причём ломает не на этапе компиляции, где ошибку поймают сразу, а во время выполнения, в неочевидном месте.&lt;/p&gt;

&lt;p&gt;Отсюда правило, сформулированное в 1994 году в книге «Приёмы объектно-ориентированного проектирования» Гаммы, Хелма, Джонсона и Влиссидеса: предпочитайте композицию объектов наследованию классов. Там же сказано - наследование нарушает инкапсуляцию, открывая наследнику внутренности предка.&lt;/p&gt;

&lt;p&gt;Разница видна на простом примере:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
// Сомнительно: отчёт наследуется ради пары чужих методов
class PdfReport : ReportBase() { /* ... */ }

// Лучше: отчёт получает то, что ему требуется, и ничего не наследует
class PdfReport(private val renderer: DocumentRenderer) { /* ... */ }&lt;/pre&gt;

&lt;p&gt;В первом варианте PdfReport связан с ReportBase всем, что в том классе есть, включая защищённые поля и порядок вызовов. Во втором он знает про renderer ровно то, что записано в его публичном интерфейсе, и переживёт любые изменения внутри.&lt;/p&gt;

&lt;p&gt;Наследование остаётся уместным там, где строится иерархия типов и любой потомок подставляется вместо предка, не нарушая ожиданий вызывающего кода. Там, где иерархия служит лишь способом переиспользовать чужой код, композиция оказывается надёжнее.&lt;/p&gt;

&lt;p&gt;Подведём промежуточный итог. Два понятия из трёх проверены. Инкапсуляция появилась раньше объектно-ориентированных языков и в них ослабла; наследование существовало как ручной приём и было улучшено, но нашу задачу не решает ни то, ни другое. Остаётся третье понятие - и с ним дело обстоит иначе.&lt;/p&gt;

&lt;h3&gt;Полиморфизм&lt;/h3&gt;

&lt;p&gt;Полиморфизм означает, что один и тот же вызов приводит к выполнению разного кода - смотря какой объект оказался на другом конце.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Применим к нашей задаче&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Вернёмся к магазину и вспомним формулировку, к которой мы пришли в начале: ordering должен знать, что заказ можно где-то сохранить и откуда-то достать, и не должен знать ничего сверх этого. Запишем знание в точности в таком объёме:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
interface OrderRepository {
    fun findById(id: OrderId): Order?
    fun save(order: Order)
}&lt;/pre&gt;

&lt;p&gt;Перед нами интерфейс - перечень обещаний без единой строки исполнения. Он утверждает: кто бы ни взялся исполнять роль хранилища заказов, он обязан уметь найти заказ по идентификатору и сохранить заказ. Каким образом - вопрос исполнителя.&lt;/p&gt;

&lt;p&gt;Код расчёта принимает такое хранилище снаружи и работает с обещаниями, а не с конкретной базой:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
class PlaceOrder(private val orders: OrderRepository) {

    fun execute(draft: OrderDraft): Result&amp;lt;Order&amp;gt; {
        val order = Order.from(draft).getOrElse { return Result.failure(it) }
        orders.save(order)                    // кто именно сохранит - неизвестно
        return Result.success(order)
    }
}&lt;/pre&gt;

&lt;p&gt;Исполнителей бывает сколько угодно, и PlaceOrder о них не знает:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
class PostgresOrderRepository(private val db: Database) : OrderRepository { /* ... */ }

class InMemoryOrderRepository : OrderRepository { /* ... */ }   // для тестов
&lt;/pre&gt;

&lt;p&gt;&lt;strong&gt;Для тех, кто только начинает:&lt;/strong&gt; бытовая аналогия - электрическая розетка. Производитель чайника не знает, какая электростанция даст ток; электростанция не знает, что к ней подключат чайник. Обе стороны знают стандарт розетки: форму разъёма, напряжение, частоту. Благодаря этому чайник работает в любом доме страны, а станцию можно заменить, не меняя чайники. Интерфейс в коде устроен так же: вместо прямого провода между двумя устройствами появляется согласованная форма разъёма. Аналогия грубая, но направление мысли передаёт.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Как это устроено внутри&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Понимать внутреннее устройство полезно: без этого полиморфизм остаётся магией, а магию трудно применять осознанно. Тем более что механизм придумали задолго до объектно-ориентированных языков - в предыдущей части мы уже отмечали, что объектно-ориентированный код пишут и на чистом C.&lt;/p&gt;

&lt;p&gt;Ядро UNIX хранило таблицу драйверов устройств. Каждая запись в ней представляла собой набор указателей на функции с заранее оговорёнными сигнатурами. В шестой и седьмой редакциях структура символьного устройства cdevsw содержала пять таких указателей: открыть, закрыть, прочитать, записать и управлять устройством. Последний назывался d_sgtty и позже превратился в привычный нам ioctl. У блочных устройств была своя, более короткая таблица: открыть, закрыть и передать запрос дисковой подсистеме.&lt;/p&gt;

&lt;p&gt;Названия и состав менялись от редакции к редакции. Неизменным оставалось главное: фиксированный набор операций с фиксированными сигнатурами, одинаковый для всех драйверов. Перед нами интерфейс, выраженный средствами языка, в котором слова «интерфейс» не было.&lt;/p&gt;

&lt;p&gt;Соберём подобную таблицу руками:&lt;/p&gt;

&lt;pre class="brush:cpp;"&gt;
/* Упрощение: в настоящем ядре структура называлась cdevsw,
   а поля - d_open, d_close, d_read, d_write, d_sgtty */
struct Device {
    void (*open)(char* name, int mode);
    int  (*read)(void);
    void (*write)(int c);
};&lt;/pre&gt;

&lt;p&gt;Драйвер консоли заполняет её указателями на собственные функции:&lt;/p&gt;

&lt;pre class="brush:cpp;"&gt;
static void consoleOpen(char* name, int mode) { /* ... */ }
static int  consoleRead(void) { int c; /* ... */ return c; }
static void consoleWrite(int c) { /* ... */ }

struct Device console = { consoleOpen, consoleRead, consoleWrite };&lt;/pre&gt;

&lt;p&gt;И чтение символа сводится к вызову через указатель. Адрес функции становится известен только во время работы программы:&lt;/p&gt;

&lt;pre class="brush:cpp;"&gt;
extern struct Device* STDIN;

int readChar(void) {
    return STDIN-&amp;gt;read();
}&lt;/pre&gt;

&lt;p&gt;В основе полиморфизма лежит именно это - вызов функции по адресу, выбранному во время выполнения. Когда вы вызываете метод интерфейса в Kotlin, работает та же модель: обращение идёт к таблице методов, соответствующей фактическому классу объекта. Разница лишь в том, что таблицу строит и проверяет компилятор, а не программист.&lt;/p&gt;

&lt;h3&gt;Зачем понадобились языки, если механизм был&lt;/h3&gt;

&lt;p&gt;Вопрос законный, и ответ на него объясняет, почему полиморфизм называют главным приобретением парадигмы.&lt;/p&gt;

&lt;p&gt;Разница между двумя записями не в возможностях, а в цене ошибки. Указатель на функцию легко забыть инициализировать - и программа прыгнет по случайному адресу. Легко перепутать порядок полей в структуре - и вызов пойдёт не туда, а компилятор промолчит, поскольку типы совпадают. Легко вызвать функцию в обход оговорённых правил. Ошибка такого рода проявляется далеко от места, где она сделана, и ищут её долго.&lt;/p&gt;

&lt;p&gt;Соглашения, прежде жившие в голове программиста, языки превратили в проверяемые правила. Компилятор строит таблицу сам, подставляет адрес сам, сверяет сигнатуры сам. Полиморфизм подешевел настолько, что его стали применять повсюду, а не в двух-трёх важных местах программы.&lt;/p&gt;

&lt;p&gt;Вот в этом смысле объектно-ориентированное программирование и накладывает ограничение на косвенную передачу управления. Оно забирает свободное обращение с указателями на функции - и взамен выдаёт механизм, за правильностью которого следит компилятор.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Программа, которой безразлично устройство мира&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Прежде чем перейти к архитектурным следствиям, посмотрим на пример, ради которого всё затевалось. Вот программа копирования, написанная на C:&lt;/p&gt;

&lt;pre class="brush:cpp;"&gt;
#include &amp;lt;stdio.h&amp;gt;

void copy(void) {
    int c;
    while ((c = getchar()) != EOF)
        putchar(c);
}&lt;/pre&gt;

&lt;p&gt;Спросим: что придётся в ней изменить, если на входе появится сканер рукописного текста, а на выходе синтезатор речи?&lt;/p&gt;

&lt;p&gt;Ничего. Программу даже не придётся пересобирать. Её исходный код не содержит ни одной ссылки на код драйверов: обращение идёт к таблице, а таблицу заполняет тот, кто подключает устройство. Пока новое устройство предоставляет оговорённый набор функций, программа с ним работает.&lt;/p&gt;

&lt;p&gt;Устройства ввода-вывода превратились в подключаемые модули - в плагины. И произошло это не из любви к абстракциям. В пятидесятых программы писали под конкретное устройство: прочитать колоду перфокарт, пробить новую колоду с результатом. Когда заказчики понесли данные на магнитной ленте, выяснилось, что программу придётся переписывать целиком, хотя логика обработки не изменилась ни на букву. Независимость от устройства оказалась условием выживания программы, а не украшением.&lt;/p&gt;

&lt;p&gt;С тех пор сменились поколения техники. Задача осталась та же, с которой мы начали статью: отделить то, что составляет существо работы, от того, через что эта работа сообщается с внешним миром.&lt;/p&gt;

&lt;p&gt;Инструмент у нас теперь есть. Посмотрим, что он делает с направлением зависимостей.&lt;/p&gt;

&lt;h2&gt;Инверсия зависимости&lt;/h2&gt;

&lt;p&gt;Для начала разведём два понятия, которые в разговоре часто сливаются в одно.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Поток управления &lt;/strong&gt;- кто кого вызывает во время работы программы. Задаётся существом дела: расчёт заказа сохраняет данные, а не наоборот.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Зависимость исходного кода &lt;/strong&gt;- кто на кого ссылается в тексте программы. Та самая строка import, с которой статья началась.&lt;/p&gt;

&lt;p&gt;До появления надёжного полиморфизма эти две вещи были связаны жёстко. Главная функция вызывает функции верхнего уровня, те - функции среднего уровня, те - нижнего. А чтобы вызвать функцию, модуль обязан на неё сослаться. Обе стрелки смотрят в одну сторону.&lt;/p&gt;

&lt;p&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/12054155/ris-1-zavisimosti-i-vyzovy.png/700b6ca6-63b4-335c-89bf-337a3ac1122a?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;em&gt;Рисунок 1. В классической многоуровневой структуре зависимость исходного кода повторяет поток управления. У архитектора нет выбора: направление связей задано тем, кто кого вызывает.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Перед нами картина, с которой статья начиналась, только нарисованная целиком. Модуль расчёта заказа вызывает хранилище - значит, импортирует его. Правила скидок оказываются привязаны к драйверу базы данных, хотя от хранилища не зависят. И так на каждом уровне.&lt;/p&gt;

&lt;p&gt;Полиморфизм эту связь разрывает.&lt;/p&gt;

&lt;p&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/12054155/ris-2-inversiya.png/bb5b463b-6d07-8243-6281-58dec7b1fea6?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Рисунок 2. Слева прямая связь: ссылка в исходном коде повторяет вызов. Справа та же пара модулей через интерфейс. Поток управления по-прежнему идёт от HL1 к ML1, а зависимость исходного кода от ML1 направлена вверх, к интерфейсу, то есть против потока управления.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Разберём правую половину рисунка по шагам, потому что в ней вся суть.&lt;/p&gt;

&lt;p&gt;Модуль верхнего уровня HL1 вызывает метод F(). В тексте программы он ссылается только на интерфейс I, который лежит здесь же, внутри его собственного модуля. Чужих имён в его коде нет.&lt;/p&gt;

&lt;p&gt;Модуль ML1 этот интерфейс реализует. Чтобы написать : I в объявлении класса, он обязан на интерфейс сослаться - и ссылается снизу вверх, пересекая границу модуля.&lt;/p&gt;

&lt;p&gt;Во время выполнения никакого интерфейса не существует. HL1 вызывает код внутри ML1 ровно так же, как вызывал бы напрямую; интерфейс - конструкция времени компиляции, уловка для сборки. Поток управления не изменился ни на шаг.&lt;/p&gt;

&lt;p&gt;Изменилось направление зависимости в тексте программы. Теперь оно противоположно направлению вызова. Этот эффект и называют инверсией зависимости.&lt;/p&gt;

&lt;p&gt;Посмотрим, как выглядит наш магазин после перестановки:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
// ===== Модуль ordering: бизнес-правила =====
// Здесь объявлен интерфейс. Ссылок на базу данных нет

interface OrderRepository {
    fun findById(id: OrderId): Order?
    fun save(order: Order)
}

class PlaceOrder(private val orders: OrderRepository) {
    fun execute(draft: OrderDraft): Result&amp;lt;Order&amp;gt; { /* ... */ }
}

// ===== Модуль persistence: деталь реализации =====
// Ссылается на модуль ordering. Обратной ссылки нет

internal class PostgresOrderRepository(
    private val db: Database
) : OrderRepository {

    override fun findById(id: OrderId): Order? =
        db.query("SELECT ... WHERE id = ?", id.value)?.toDomain()

    override fun save(order: Order) {
        db.upsert(order.toRow())
    }
}&lt;/pre&gt;

&lt;p&gt;Сравним с тем, с чего мы начинали, и отметим, что именно изменилось.&lt;/p&gt;

&lt;p&gt;Строка import persistence.PostgresOrderRepository из модуля ordering исчезла. Вместо неё появилась ссылка в обратную сторону: модуль persistence упоминает OrderRepository из модуля ordering. Вызов при этом идёт по-прежнему из бизнес-логики в базу - пользователь магазина оформляет заказ, расчёт просит сохранить, база сохраняет.&lt;/p&gt;

&lt;p&gt;Вернёмся к вопросу, который мы поставили вначале: что ordering обязан знать о внешнем мире. Теперь ответ записан буквально - интерфейсом из двух методов. Знание об устройстве хранилища из модуля ушло, необходимое знание осталось.&lt;/p&gt;

&lt;p&gt;Тот же приём применим и к остальным стрелкам с первого рисунка. Вернитесь к нему мысленно и представьте, что направление каждой задаётся отдельно, независимо от того, кто кого вызывает. Архитектор получает контроль над структурой связей в тексте программы - а эта структура, как мы говорили в первой части, и определяет стоимость будущих изменений.&lt;/p&gt;

&lt;p&gt;Приём несложен. Возможно, поэтому его часто применяют формально, не получая обещанного результата. Об этом стоит сказать отдельно.&lt;/p&gt;

&lt;h2&gt;Кому принадлежит интерфейс&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Интерфейс стоит объявлять в модуле, который им пользуется, а не в том, который его реализует.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Объявите OrderRepository в модуле persistence, рядом с реализацией, - и инверсии не получится. Бизнес-логике придётся импортировать тип из модуля базы данных: теперь уже интерфейс, а не класс. Стрелка осталась на месте, а сущностей в системе стало больше.&lt;/p&gt;

&lt;p&gt;Проверить себя несложно. Удалите модуль persistence из сборки целиком и попробуйте скомпилировать ordering. Собралось - инверсия настоящая. Не собралось - значит, перед нами декорация.&lt;/p&gt;

&lt;p&gt;Из того же рассуждения следует второе правило, менее очевидное. Интерфейс описывает потребность вызывающей стороны, а не возможности реализации. Разница видна на примере:&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
// Признак проблемы: интерфейс описывает устройство хранилища
interface OrderRepository {
    fun executeQuery(sql: String): ResultSet
    fun beginTransaction(): Transaction
}

// Лучше: интерфейс описывает потребность бизнес-логики
interface OrderRepository {
    fun findById(id: OrderId): Order?
    fun save(order: Order)
}
&lt;/pre&gt;

&lt;p&gt;Второй вариант переживёт смену хранилища - хоть на документную базу, хоть на внешнюю службу, хоть на файл. Первый не переживёт: в него уже протекли понятия конкретной технологии, строка запроса и транзакция. Формально инверсия выполнена, фактически бизнес-логика по-прежнему рассуждает в терминах реляционной базы.&lt;/p&gt;

&lt;p&gt;Распознаётся такой интерфейс по характерному признаку: он слово в слово повторяет публичные методы одного конкретного класса. Писали его, глядя на реализацию, а не на потребность. Пользы от него немного - меняться он будет ровно тогда же, когда меняется класс.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Для специалистов с опытом&lt;/strong&gt;: стоит разделять три вещи, которые иногда путают. Инверсия зависимости - принцип, касающийся направления ссылок в исходном коде. Внедрение зависимостей - приём передачи реализации в объект, и работает он через обычный конструктор, безо всяких библиотек. Контейнер внедрения зависимостей - механика сборки объектного графа, удобная в больших системах. Подключение контейнера само по себе инверсии не даёт: при интерфейсе, объявленном не в том модуле, направление стрелок от фреймворка не зависит.&lt;/p&gt;

&lt;h2&gt;Что это даёт системе&lt;/h2&gt;

&lt;p&gt;Получив контроль над направлением зависимостей, систему выстраивают так, чтобы пользовательский интерфейс и база данных зависели от бизнес-правил, а не наоборот.&lt;/p&gt;

&lt;p&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/12054155/ris-3-yadro-i-plaginy.png/6efb2be2-9281-00a5-2933-f4292bfcfb93?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Рисунок 3. Все стрелки зависимости направлены внутрь, к бизнес-правилам, хотя поток управления идёт в обе стороны. Интерфейс, хранилище и внешние службы становятся сменными модулями вокруг неизменного ядра.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;В коде бизнес-правил нет упоминаний ни об интерфейсе, ни о базе данных, ни о платёжном шлюзе. Всё это стало плагинами - подключаемыми модулями, замена которых ядра не касается. Ровно как устройства ввода-вывода для программы копирования, только на уровне целой системы.&lt;/p&gt;

&lt;p&gt;Из такой схемы вытекают три следствия. Каждое сокращает свою статью расходов - те самые усилия на изменения, которые в первой части мы назвали мерилом архитектуры.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Независимость сборки&lt;/strong&gt;. Бизнес-правила, интерфейс и работа с данными собираются в три отдельных модуля, и модуль бизнес-правил не зависит ни от одного из остальных.&lt;/p&gt;

&lt;p&gt;Сокращается рабочее время. Правка задевает один модуль - пересобирается один модуль, и цикл «изменил, собрал, проверил» укорачивается. Эффект заметен не столько на отдельной правке, сколько на их количестве: за день разработчик проходит этот цикл много раз. Есть и побочное следствие: при долгой сборке её перестают запускать после каждой мелкой правки, изменения копятся пачками, и ошибки в них обнаруживаются позже, чем могли бы.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Независимость развёртывания&lt;/strong&gt;. Изменилась реализация хранилища - пересобрать и выкатить придётся только её, остальная система не затронута.&lt;/p&gt;

&lt;p&gt;Экономия здесь не на сборке, а на проверках и риске. Выкатывая один модуль, вы проверяете один модуль; при отказе откатываете тоже один. Объём регрессионного тестирования и площадь возможной поломки задаются не размером правки, а размером уезжающего в продакшен. В системе, собираемой целиком, однострочное изменение обходится в полную цену проверки - отсюда редкие релизы крупными партиями.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Независимость разработки&lt;/strong&gt;. Модули, развёртываемые по отдельности, можно и писать по отдельности - разными людьми, разными командами.&lt;/p&gt;

&lt;p&gt;Сокращается согласование. Стоимость его растёт не столько от числа людей, сколько от числа мест пересечения их работы. Интерфейс сводит переговоры к разовой договорённости: условились один раз, дальше две команды идут параллельно, не дожидаясь друг друга.&lt;/p&gt;

&lt;p&gt;Конкретные цифры здесь привести не получится - они зависят от размера системы, частоты релизов и устройства сборки, и переносить их с проекта на проект бессмысленно. Но статьи расходов именно эти три, и разговор с руководством в них ведётся предметнее, чем в абстрактном «качестве кода».&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Четвёртое следствие: возвращение к тесту&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Среди четырёх ограничений, перечисленных в начале статьи, было одно, к которому стоит вернуться отдельно: модуль нельзя проверить без базы данных. Посмотрим, что с ним стало.&lt;/p&gt;

&lt;pre class="brush:java;"&gt;
class InMemoryOrderRepository : OrderRepository {
    private val storage = mutableMapOf&amp;lt;OrderId, Order&amp;gt;()
    override fun findById(id: OrderId) = storage[id]
    override fun save(order: Order) { storage[order.id] = order }
}

@Test
fun `заказ с пустой корзиной не принимается`() {
    val useCase = PlaceOrder(InMemoryOrderRepository())

    val result = useCase.execute(OrderDraft(items = emptyList()))

    assertTrue(result.isFailure)
}&lt;/pre&gt;

&lt;p&gt;Ни базы данных, ни контейнера, ни сетевых вызовов. Хранилище подменено словарём в памяти, и бизнес-логика подмены не заметила: обе реализации одинаково выполняют обещание. Тест отрабатывает быстро и падает тогда, когда сломана именно бизнес-логика.&lt;/p&gt;

&lt;p&gt;Заметим, что ради тестов ничего не делалось. Зависимости разворачивались ради независимой сборки и сменных модулей, а тестируемость появилась следом. В предыдущей части мы приходили к этому с другой стороны и сформулировали так: если что-то трудно протестировать, проблема почти никогда не в тестах, проблема в структуре. Там же отмечалось, что скрытые зависимости стоит превращать в явные параметры. Интерфейс в модуле ordering - это та же мысль, применённая не к одной функции, а к границе между модулями.&lt;/p&gt;

&lt;h2&gt;Где этого делать не надо&lt;/h2&gt;

&lt;p&gt;Инвертировать все зависимости подряд незачем, и статья была бы неполной без разговора о цене.&lt;/p&gt;

&lt;p&gt;Каждый интерфейс - дополнительная сущность, лишний уровень косвенности и чуть большее усилие при чтении кода. Переходя по вызову, читатель попадает не в реализацию, а в объявление, и выясняет отдельно, кто за этим объявлением стоит. В большой системе такие прыжки накапливаются.&lt;/p&gt;

&lt;p&gt;Платить эту цену стоит там, где проходит граница: между бизнес-логикой и внешним миром. База данных, сторонние службы, файловая система, доставка сообщений, пользовательский интерфейс - всё неподконтрольное системе и способное смениться по причинам, к бизнес-логике отношения не имеющим.&lt;/p&gt;

&lt;p&gt;Внутри одного смыслового слоя интерфейсы чаще мешают. Класс, считающий налог, и класс, применяющий скидку, живут в одном модуле, меняются по одним и тем же причинам, выкатываются вместе. &lt;meta charset="UTF-8" /&gt;Интерфейс между ними не даёт ничего: он существует ради того, чтобы одну сторону можно было подменить независимо от другой, а подменять пока нечего - второй реализации расчёта налога в системе нет.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;Возражение напрашивается само: а вдруг она появится? Налоговые правила отличаются от страны к стране, и вторая схема расчёта - вещь вполне вероятная. Если она появится, критерий сработает в её пользу: как только вторую реализацию можно будет назвать, интерфейс станет оправдан. Утверждение здесь не в том, что он не понадобится никогда, а в том, что заводить его под предположение - значит платить за дополнительный уровень косвенности, ничего пока не получая взамен.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Практический ориентир&lt;/strong&gt;: &lt;meta charset="UTF-8" /&gt;инвертируйте зависимость там, где вы можете внятно назвать второй возможный вариант реализации - уже существующий или тот, к которому система явно идёт. Для хранилища он есть почти всегда: хотя бы версия в памяти, которую мы написали для теста. Если же на вопрос «а какая здесь может быть вторая реализация?» ответа не находится, интерфейс, скорее всего, преждевременен. Появится второй вариант позже - интерфейс можно будет извлечь, и основную часть этой работы сделает среда разработки.&lt;/p&gt;

&lt;p&gt;Здесь же пригождается приём, упомянутый&amp;nbsp;в разделе об инкапсуляции. Классы внутри модуля-плагина помечают как internal: наружу торчит только реализуемый интерфейс, остальное соседям недоступно даже при желании. Граница, проведённая направлением зависимостей, подкрепляется границей видимости - и две меры вместе работают надёжнее каждой по отдельности.&lt;/p&gt;

&lt;h2&gt;Заключение&lt;/h2&gt;

&lt;p&gt;Соберём сказанное.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Статья началась с четырёх ограничений, в которые упирается модуль бизнес-логики, сославшийся на базу данных: его не собрать отдельно, не проверить без базы, трудно передать другой команде, а замена хранилища задевает правила расчёта. Источником всех четырёх оказалось избыточное знание: модуль знал об устройстве хранилища больше, чем требовала его собственная работа.&lt;/p&gt;

&lt;p&gt;Из трёх понятий, которыми принято определять объектно-ориентированное программирование, два к решению этой задачи не ведут. Инкапсуляция появилась раньше объектно-ориентированных языков и в них ослабла: в C структура скрывалась целиком, в C++ поля переехали в заголовок, в Java и Kotlin приватность держится на обещании компилятора. Рабочая граница сегодня проходит по модулю сборки, а не по ключевому слову private. Наследование тоже существовало до появления языков - в виде ручного приёма с совпадающей раскладкой полей. Языки сделали его безопасным, но связь оно создаёт жёсткую, затрагивающую внутреннее устройство предка, и композиция нередко оказывается удачнее.&lt;/p&gt;

&lt;p&gt;Задачу решает третье понятие. Полиморфизм был возможен и раньше - через таблицы указателей на функции, как в драйверах UNIX, - но обходился слишком дорого в ошибках, чтобы применять его повседневно. Языки сделали его дешёвым и проверяемым, и этим открыли приём, недоступный прежде.&lt;/p&gt;

&lt;p&gt;Приём состоит в том, что интерфейс объявляется в модуле-потребителе, а реализация ссылается на него снизу вверх. Поток управления при этом остаётся прежним, а зависимость исходного кода разворачивается против него. Для архитектора объектно-ориентированное программирование означает прежде всего эту возможность: направление каждой связи в тексте программы задаётся отдельно, независимо от того, кто кого вызывает.&lt;/p&gt;

&lt;p&gt;Из такого контроля вырастает архитектура сменных модулей, где база данных и пользовательский интерфейс становятся плагинами к бизнес-правилам. Выигрыш распределяется по трём статьям расходов: время сборки, объём проверок при релизе, затраты на согласование между командами. Тестируемость при этом получается побочным следствием, а не отдельной работой.&lt;/p&gt;

&lt;p&gt;Две оговорки, без которых приём превращается в ритуал. Первая: интерфейс стоит объявлять там, где им пользуются, а не там, где его реализуют, - проверяется мысленным удалением модуля с реализацией. Вторая: инвертировать всё подряд не нужно, интерфейс оправдан на границе, за которой лежит внешний мир или реальная альтернатива.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;&lt;strong&gt;Спасибо, что дочитали до конца.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;В следующей части мы разберём третью, последнюю парадигму - функциональное программирование. Поговорим о том, почему ограничение на присваивание оказалось не причудой математиков, что такое функциональное ядро в императивной оболочке и почему хранение событий вместо текущего состояния меняет взгляд на устройство данных.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;em&gt;Следите за продолжением.&lt;/em&gt;&lt;/strong&gt;&lt;/p&gt;</summary>
    <dc:creator>Romo Fedoroff</dc:creator>
    <dc:date>2026-10-06T12:06:00Z</dc:date>
  </entry>
  <entry>
    <title>Thick vs Thin WAR и что использовать в современном Liferay</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21315139" />
    <author>
      <name>Никита Рогаленко</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21315139</id>
    <updated>2026-10-05T10:11:37Z</updated>
    <published>2026-10-05T10:06:00Z</published>
    <summary type="html">&lt;p style="text-align: justify;"&gt;При разработке порталов на базе Liferay (и не только их) рано или поздно приходится столкнуться с выбором между двумя разными архитектурными подходами Thick WAR («толстый» war) и Thin WAR («тонкий» war). Эти понятия характеризуют тот способ, которым создается архив веб-приложений, определяя, как именно упаковываются зависимости, что критически влияет на скорость деплоя, потребление памяти и стабильность серверов приложений, будь то легковесный Tomcat или модульный WildFly. Разберем суть обоих подходов, их плюсы, минусы и то, как они уживаются с OSGi-контейнером современного Liferay.&lt;/p&gt;

&lt;h3 style="text-align: justify;"&gt;&lt;strong&gt;Суть вопроса&lt;/strong&gt;&lt;/h3&gt;

&lt;p style="text-align: justify;"&gt;Главное отличие между этими подходами кроется в вопросе, где лежат сторонние библиотеки (JAR-файлы), нужные для работы приложения Thick WAR собирается по принципу «все необходимые зависимости должны лежать в том же архиве». Все тяжелые библиотеки (например, Spring, JSF, PrimeFaces) упаковываются прямо внутрь архива в папку WEB-INF/lib. На выходе получается тяжелый файл размером в несколько десятков мегабайт. Thin WAR же подразумевает почти пустую папку WEB-INF/lib. Все сторонние библиотеки объявляются как provided (то есть должны быть предоставлены приложению средой исполнения) и деплоятся в Liferay один раз в виде глобальных модулей. Сам WAR-файл содержит только скомпилированный код и весит, как правило, меньше мегабайта.&lt;/p&gt;

&lt;h3 style="text-align: justify;"&gt;&lt;strong&gt;А как в Liferay?&lt;/strong&gt;&lt;/h3&gt;

&lt;p style="text-align: justify;"&gt;Во время деплоя .war-файла в Liferay сервер не запускает архив напрямую. Внутри Liferay работает специальный инструмент – WAB Generator (Web Application Bundle), который трансформирует классический веб-архив в понятный для OSGi-контейнера модуль. И вот тут начинается разница в поведении серверов. При тонком подходе все общие библиотеки загружаются в память OSGi-контейнера (osgi/modules) только один раз. Портлет в своем конфигурационном файле указывает импорты нужных пакетов, а серверу не нужно создавать новые сущности в памяти, поскольку все портлеты смотрят на одни и те же разделяемые библиотеки. Деплой же становится быстрым. При толстом подходе в каждом из .war файлов в WEB-INF/lib будет лежать своя копия PrimeFaces и JSF-библиотек. Сервер приложений будет вынужден создать изолированный ClassLoader для каждого архива. В итоге в оперативной памяти сервера десятки одинаковых классов могут дублироваться, что приводит к огромному расходу RAM, долгому парсингу файлов при деплое и высокому риску поймать OutOfMemoryError. Поэтому, если используется Thick WAR, то выгоднее всегда упаковывать все портлеты в один war архив, тогда тяжелые Jakarta-версии PrimeFaces и JSF-мостов загрузятся в память в единственном экземпляре, не занимая лишнюю память, а все портлеты внутри этого WAR будут использовать общие классы.&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;Стоит также учитывать особенности используемого сервера приложений. С Apache Tomcat больше шансов, что все заведется «из коробки», поскольку Tomcat изолирует WEB-INF/lib WAR-файла, берет оттуда библиотеки и запускает портлеты. WildFly же представляет собой полноценный Jakarta EE сервер, у которого есть собственная встроенная подсистема JSF. Если просто задеплоить «толстый» WAR, библиотеки внутри архива начнут конфликтовать с библиотеками самого WildFly, и сервер упадет с ошибкой ClassCastException.Чтобы Thick WAR заработал на WildFly, придется принудительно изолировать серверный JSF, разбираться с настройками сервера и конфигурацией jboss-deployment-structure.xml.&lt;/p&gt;

&lt;h3 style="text-align: justify;"&gt;&lt;strong&gt;Что же выбрать?&lt;/strong&gt;&lt;/h3&gt;

&lt;p style="text-align: justify;"&gt;В современной разработке под Liferay идеальный путь – это уход от WAR в сторону чистых OSGi JAR-модулей. Но если нужен именно .war (например, при миграции старого проекта), то нужно помнить следующее:&lt;/p&gt;

&lt;ul&gt;
	&lt;li style="text-align: justify;"&gt;&lt;strong&gt;Thick WAR&lt;/strong&gt; – это большой размер артефактов, хранение всех зависимостей в том же архиве, больше ресурсов и времени деплоя, зато потенциально решает возможные проблемы с отсутствием нужных зависимостей во время исполнения приложения.&lt;/li&gt;
	&lt;li style="text-align: justify;"&gt;&lt;strong&gt;Thin WAR&lt;/strong&gt; – это легковесное решение, которое делегирует хранение зависимостей OSGI, ускоряя деплой, но (возможно) требующее для сборки собственноручного добавления зависимостей в OSGI контейнер&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;&amp;nbsp;&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;&amp;nbsp;&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;&amp;nbsp;&lt;/p&gt;</summary>
    <dc:creator>Никита Рогаленко</dc:creator>
    <dc:date>2026-10-05T10:06:00Z</dc:date>
  </entry>
  <entry>
    <title>Проверяем SSO сессию в открытой вкладке</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21304495" />
    <author>
      <name>Maxim Kalabukhov</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21304495</id>
    <updated>2026-09-09T16:19:25Z</updated>
    <published>2026-09-09T16:15:00Z</published>
    <summary type="html">&lt;p&gt;В одном из проектов мне понадобилось отслеживать состояние SSO-сессии на уже открытой странице. Пользователь выходит из SSO через другое приложение, а наш фронт продолжает показывать прежний интерфейс. Хотелось, чтобы страница сама узнавала об изменении и подтягивала актуальное состояние пользователя.&lt;/p&gt;

&lt;p&gt;Механизм описан в &lt;a href="https://openid.net/specs/openid-connect-session-1_0.html"&gt;OpenID Connect Session Management 1.0&lt;/a&gt;. Дальше расскажу, как я встраивал этот механизм в проект на React и Django с Keycloak.&lt;/p&gt;

&lt;h2&gt;Как я это реализовал&lt;/h2&gt;

&lt;p&gt;Авторизация в приложении уже работала: браузер уходил в Keycloak, возвращался на callback, backend создавал Django сессию. Полученный при входе &lt;code&gt;session_state&lt;/code&gt; сохранялся на сервере. Его и предстояло передавать на фронт для последующих проверок.&lt;/p&gt;

&lt;p&gt;На фронте я вынес мониторинг в отдельный React-компонент &lt;code&gt;SsoSessionManager&lt;/code&gt;. Он подключается при наличии авторизованного пользователя, ничего не рисует и управляет двумя скрытыми iframe. Один живёт всё время работы manager, второй появляется только для уточнения состояния сессии. Авторизация и работа с токенами оставались на бэкенде, а фронту требовались конфигурация проверки и её результат.&lt;/p&gt;

&lt;p&gt;Чтобы фронт мог получить контекст мониторинга, а backend - отдельно от обычного логина уточнить SSO-сессию и обработать результат, я добавил три новые ручки: &lt;code&gt;GET /api/auth/sso-session&lt;/code&gt; отдаёт конфигурацию и сохранённый &lt;code&gt;session_state&lt;/code&gt;, &lt;code&gt;GET /auth/sso-session/start&lt;/code&gt; подготавливает временный флоу авторизации и перенаправляет iframe в Keycloak, а &lt;code&gt;GET /auth/sso-session/callback&lt;/code&gt; обрабатывает ответ Keycloak и возвращает HTML во временный iframe. Скрипт этого документа передаёт результат проверки родительской странице через postMessage.&lt;/p&gt;

&lt;p&gt;Постоянный iframe загружает &lt;code&gt;login-status-iframe.html&lt;/code&gt; из Keycloak. После загрузки &lt;code&gt;SsoSessionManager&lt;/code&gt; отправляет в него через &lt;code&gt;postMessage&lt;/code&gt; строку &lt;code&gt;client_id + " " + session_state&lt;/code&gt;. Пока вкладка скрыта, опрос SSO приостанавливается, а при возвращении проверка запускается снова. Всего, при опросе SSO, может вернуться 3 состояния: При &lt;code&gt;unchanged&lt;/code&gt; продолжаем проверять. При &lt;code&gt;changed&lt;/code&gt; останавливаем опрос и создаём временный iframe с адресом &lt;code&gt;/auth/sso-session/start&lt;/code&gt;. Сам по себе &lt;code&gt;changed&lt;/code&gt; ещё не сообщает, нужно ли завершать локальную сессию, поэтому дальше разбирается backend. При &lt;code&gt;error&lt;/code&gt; manager отключает мониторинг для текущей страницы.&lt;/p&gt;

&lt;p&gt;Ручка &lt;code&gt;/start&lt;/code&gt; проверяет локальную сессию, создаёт одноразовые &lt;code&gt;state&lt;/code&gt; и &lt;code&gt;nonce&lt;/code&gt;, сохраняет ожидаемого пользователя. Затем перенаправляет временный iframe на авторизационную ручку Keycloak с &lt;code&gt;prompt=none&lt;/code&gt;. Этот параметр запрещает показывать форму логина и другие интерактивные экраны. Keycloak пытается выполнить запрос на основе уже существующего входа в браузере: если это возможно, возвращает code, но если нужно участие пользователя, то возвращает ошибку. Для нас это способ уточнить состояние SSO в скрытом iframe, не уводя пользователя с открытой страницы и не заставляя его снова вводить пароль.&lt;/p&gt;

&lt;p&gt;Чтобы уточнить состояние входа в Keycloak без участия пользователя, &lt;code&gt;SsoSessionManager&lt;/code&gt; задаёт временному iframe &lt;code&gt;src="https://www.tune-it.ru/auth/sso-session/start"&lt;/code&gt;. Браузер проходит внутри этого iframe цепочку редиректов для проверки входа в Keycloak, а &lt;code&gt;/auth/sso-session/callback&lt;/code&gt; отдаёт небольшой HTML со скриптом, вызывающим &lt;code&gt;window.parent.postMessage&lt;/code&gt;, который отправляет результат родительской странице.&lt;/p&gt;

&lt;p&gt;Когда Keycloak возвращает code на &lt;code&gt;/auth/sso-session/callback&lt;/code&gt;, Django обменивает его на токены отдельным серверным запросом. Backend делает необходимые проверки, затем сверяет &lt;code&gt;sub&lt;/code&gt; с ожидаемым и текущим локальным пользователем. Если пользователь тот же, то сохраняется новый &lt;code&gt;session_state&lt;/code&gt;. Инные случаи приводят к завершению локальной сессии. &lt;code&gt;SsoSessionManager&lt;/code&gt; проверяет origin, окно-источник и структуру сообщения. Если пришёл &lt;code&gt;session_updated&lt;/code&gt;, забирает новый &lt;code&gt;session_state&lt;/code&gt;, удаляет временный iframe и возобновляет опрос SSO. Если &lt;code&gt;logged_out&lt;/code&gt; - отключает мониторинг и обновляет страницу.&lt;/p&gt;</summary>
    <dc:creator>Maxim Kalabukhov</dc:creator>
    <dc:date>2026-09-09T16:15:00Z</dc:date>
  </entry>
  <entry>
    <title>Продвинутая типографика в вебе, как делать текст быстрым и красивым</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21304195" />
    <author>
      <name>Алексей Кондратьев</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21304195</id>
    <updated>2026-09-08T21:07:57Z</updated>
    <published>2026-09-08T21:03:00Z</published>
    <summary type="html">&lt;p&gt;Каждый, кто пользуется интернетом, сталкивался с ситуацией, когда текст на сайте сначала показывается одним шрифтом, а через секунду «прыгает», меняя размер и положение, когда подгружается «правильное» начертание. Или страница вовсе отказывается показывать текст, пока не загрузятся все шрифты. Подобные сценарии не просто раздражают — они разрушают пользовательский опыт, портят поведенческие метрики и заставляют людей уходить, так и не дождавшись содержимого.&lt;/p&gt;

&lt;p&gt;Типографика в вебе — это всегда компромисс между красотой и скоростью. Между тем, как вы хотите, чтобы выглядел ваш проект, и тем, как быстро он будет загружаться.&amp;nbsp;&lt;/p&gt;

&lt;h2&gt;Вариативные шрифты: Один файл вместо двадцати&lt;/h2&gt;

&lt;p&gt;Раньше, чтобы использовать шрифт в разных начертаниях, нужно было подключать отдельные файлы: Roboto Regular, Roboto Bold, Roboto Italic, Roboto Bold Italic… И так для каждого веса и стиля. Это создавало кучу HTTP-запросов и заставляло пользователя скачивать мегабайты данных. Вариативные шрифты решили эту проблему кардинально.&lt;/p&gt;

&lt;p&gt;Один файл — и внутри него все варианты: от самого тонкого до самого жирного, от узкого до широкого, с курсивом и без. Это дало колоссальную свободу. Вы больше не привязаны к фиксированным значениям вроде 400 или 700. Хотите вес 437? Пожалуйста. 582? Без проблем. Вы можете плавно менять толщину шрифта в зависимости от контекста, создавая более тонкую и выразительную типографику.&lt;/p&gt;

&lt;p&gt;Технически это работает через так называемые «оси вариаций» — параметры, которые можно настраивать. Основные оси стандартизированы: это вес (wght), ширина (wdth), и курсив (ital). Но производители шрифтов могут добавлять и свои, уникальные оси — например, для изменения наклона или даже размера засечек.&lt;/p&gt;

&lt;p&gt;Важный нюанс: если вы подключаете вариативный шрифт, в CSS вам не нужно указывать конкретный вес при загрузке. Вместо weight: '400' вы просто пишете weight: 'variable', а затем используете свойство font-variation-settings, чтобы управлять всеми доступными осями. Это невероятно гибко и мощно.&lt;/p&gt;

&lt;h2&gt;Модульные шкалы и математика текста&lt;/h2&gt;

&lt;p&gt;Красивая типографика не рождается из хаоса. Она подчиняется математике. В основе лежит понятие модульной шкалы — последовательности чисел, где каждое следующее получается из предыдущего путем умножения на постоянный коэффициент. Например, коэффициент 1.25 даёт малую терцию, 1.333 — чистую кварту, а 1.618 — знаменитое золотое сечение.&lt;/p&gt;

&lt;p&gt;Зачем это нужно? Чтобы все размеры текста на вашем сайте — от самого маленького подписи до огромного заголовка — были ритмически связаны друг с другом. Глаз чувствует эту гармонию, даже если вы не можете объяснить её словами. Это создает ощущение цельности и профессионализма.&lt;/p&gt;

&lt;p&gt;Современные инструменты позволяют автоматизировать этот процесс. Например, есть специальные утилиты, которые генерируют CSS-переменные для каждого шага шкалы, а заодно добавляют к ним плавную адаптивность . Задача дизайнера — не считать вручную, а выбрать правильное соотношение и проверить, насколько хорошо оно работает в контексте проекта.&lt;/p&gt;

&lt;h2&gt;Адаптивная типографика: Когда текст сам знает, где находится&lt;/h2&gt;

&lt;p&gt;Помните старый добрый способ: для мобильных экранов — один размер, для планшетов — чуть больше, для десктопов — ещё больше? Это работало, но с одним недостатком: на промежуточных размерах, между вашими брейкпоинтами, текст выглядел либо слишком маленьким, либо слишком большим.&lt;/p&gt;

&lt;p&gt;Современный подход — жидкая типографика (fluid typography) на основе CSS-функции clamp(). Вместо того чтобы задавать фиксированные значения для разных разрешений, вы определяете диапазон: минимальный размер, максимальный размер и скорость изменения между ними.&lt;/p&gt;

&lt;p&gt;Например, вы пишете: font-size: clamp(1rem, 2vw + 0.5rem, 2.5rem). Это значит: «На маленьких экранах размер будет не меньше 1rem, на больших — не больше 2.5rem, а между ними он будет плавно меняться в зависимости от ширины окна». Текст не делает резких скачков. Он словно «дышит» вместе с экраном.&lt;/p&gt;

&lt;p&gt;Некоторые системы идут дальше. Они генерируют целые шкалы clamp() — для каждого типографического уровня, от самого маленького до самого большого. И делают это не только для размера шрифта, но и для интерлиньяжа, отступов, ширины колонок . Результат — интерфейс, который выглядит одинаково гармонично на любом устройстве: от маленького телефона до огромного 4K-монитора.&lt;/p&gt;

&lt;h2&gt;Загрузка шрифтов: Битва с FOUT и FOIT&lt;/h2&gt;

&lt;p&gt;Самая большая боль веб-типографики — это то, как браузер ведёт себя, пока шрифт не загрузился. Здесь у нас два злодея:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;FOIT (Flash of Invisible Text) — текст не показывается вообще. Вы видите пустую страницу с картинками, но без единой буквы. Это ужасно для пользовательского опыта .&lt;/li&gt;
	&lt;li&gt;FOUT (Flash of Unstyled Text) — текст показывается системным шрифтом (например, Arial), а потом, когда загружается ваш красивый шрифт, он «перепрыгивает». В этот момент может произойти смещение макета, потому что размеры шрифтов отличаются . Это бьёт по показателю Cumulative Layout Shift (CLS) в Core Web Vitals.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;И то, и другое плохо. Спасает нас свойство font-display. Его можно задать внутри @font-face. Вариантов несколько:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;swap — показывает системный шрифт сразу, а когда загрузится ваш — заменяет его. Это даёт быстрый FCP (First Contentful Paint), но вы рискуете получить FOUT и смещение.&lt;/li&gt;
	&lt;li&gt;fallback — даёт браузеру 100 миллисекунд на ожидание (текст скрыт), потом показывает системный. Если через 3 секунды шрифт не загрузился — системный остаётся навсегда. Хороший компромисс.&lt;/li&gt;
	&lt;li&gt;optional — ещё более строгий вариант. Если шрифт не загрузился за 100 мс, он больше никогда не заменится. Это полностью предотвращает смещение, но ваш «красивый» шрифт может так и не появиться.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Самый надежный способ избежать проблем — использовать font-display: swap в сочетании с предзагрузкой (preload) критически важных шрифтов. Вы говорите браузеру: «Загрузи этот шрифт в первую очередь, он очень нужен». Это ускоряет загрузку, но злоупотреблять не стоит.&lt;/p&gt;

&lt;p&gt;Кстати, современные фреймворки вроде Next.js решают эту проблему автоматически. Они сами хостят шрифты на вашем сервере, подгружают их на этапе сборки, а сгенерированный CSS использует технику size-adjust, чтобы системный шрифт и ваш шрифт занимали одинаковое пространство. Таким образом, даже до загрузки вашего шрифта нет смещения макета — текст просто «обновляется» внешне, но не дергается.&lt;/p&gt;

&lt;h2&gt;Практические шаги к идеальной типографике&lt;/h2&gt;

&lt;ol&gt;
	&lt;li&gt;Выбор шрифта. Отдавайте предпочтение вариативным шрифтам. Это даёт гибкость и экономию трафика. Используйте WOFF2 — самый сжатый современный формат.&lt;/li&gt;
	&lt;li&gt;Построение модульной шкалы. Используйте инструменты для генерации типографической шкалы с выбранным коэффициентом (например, малая терция 1.25 или идеальная кварта 1.333). Сгенерируйте CSS-переменные для каждого размера.&lt;/li&gt;
	&lt;li&gt;Адаптивность. Примените clamp() к вашим переменным. Не для всех сразу, а с умом: для заголовков — более широкий диапазон (чтобы они были действительно разными на большом и маленьком экране), для основного текста — более узкий.&lt;/li&gt;
	&lt;li&gt;Загрузка. Используйте font-display: swap. Предзагружайте только один-два самых важных шрифта — те, что сразу видны на первом экране. Остальные могут загружаться лениво.&lt;/li&gt;
	&lt;li&gt;Проверка. Обязательно смотрите на сайт через Lighthouse. Он подскажет, нет ли проблем с CLS или с тем, что текст остаётся невидимым.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Типографика — это не просто «выбрать красивый шрифт». Это сложная инженерная задача, которая требует понимания как эстетики, так и технологий. Но когда вы находите правильный баланс, текст на вашем сайте становится не просто читаемым, а по-настоящему живым: быстрым, плавным и гармоничным. И это то, что пользователи чувствуют, даже если не могут объяснить почему.&lt;br /&gt;
&amp;nbsp;&lt;/p&gt;</summary>
    <dc:creator>Алексей Кондратьев</dc:creator>
    <dc:date>2026-09-08T21:03:00Z</dc:date>
  </entry>
  <entry>
    <title>Полезные Maven/Gradle плагины для Liferay разработки</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21303697" />
    <author>
      <name>Никита Рогаленко</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21303697</id>
    <updated>2026-09-07T15:38:55Z</updated>
    <published>2026-09-07T15:36:00Z</published>
    <summary type="html">&lt;p style="text-align: justify;"&gt;Разработка&amp;nbsp; корпоративных решений и интранет-порталов на базе Liferay требует управления сложной экосистемой, включая инициализацию серверов приложений, сборку различных модулей, работу с базой данных и REST-эндпоинтами. Чтобы ускорить разработку, Liferay предоставляет специализированный инструментарий в форме плагинов для популярных систем сборки, таких как Gradle и Maven.&amp;nbsp;В этой заметке мы представим краткий обзор некоторых таких плагинов, которые позволяют автоматизировать рутинные операции и сделать процесс разработки эффективнее. Сегодня в нашей подборке 4 плагина&lt;/p&gt;

&lt;h3 style="text-align: justify;"&gt;1. com.liferay.portal.tools.bundle.support&lt;/h3&gt;

&lt;p style="text-align: justify;"&gt;Представляет собой плагин для инфраструктуры,&amp;nbsp;управления окружением и CI/CD. Реализует парадигму «Инфраструктура как код», позволяя избавиться от ручного скачивания архивов портала, распаковки и самостоятельного копирования конфигураций. Этот плагин берет под свой контроль весь жизненный цикл Liferay бандла.&amp;nbsp;На основе указанного URL или версии плагин скачивает сборку сервера (например, Tomcat bundle) и кэширует архив в локальной файловой системе сборщика. Также плагин полностью очищает целевую директорию и разворачивает чистый инстанс Liferay, убирая все временные файлы, которые могут помешать деплою, исключая тем самым появление мусорных артефактов и кэша от старых запусков.&amp;nbsp;Плагин также может накладывать файлы настроек (такие как portal-ext.properties или system-ext.properties) поверх чистого лайфрея в зависимости от выбранного профиля сборки (например, local, dev, test). Конфигурация разбивается на шаги (executions) в рамках конкретных фаз жизненного цикла (покажем пример для maven):&lt;/p&gt;

&lt;pre class="brush:xml;"&gt;
&amp;lt;project xmlns="http://apache.org" 
         xmlns:xsi="http://w3.org"
         xsi:schemaLocation="http://apache.org http://apache.org"&amp;gt;
    &amp;lt;modelVersion&amp;gt;4.0.0&amp;lt;/modelVersion&amp;gt;

    &amp;lt;groupId&amp;gt;com.example.liferay&amp;lt;/groupId&amp;gt;
    &amp;lt;artifactId&amp;gt;liferay-workspace-project&amp;lt;/artifactId&amp;gt;
    &amp;lt;version&amp;gt;1.0.0-SNAPSHOT&amp;lt;/version&amp;gt;
    &amp;lt;packaging&amp;gt;pom&amp;lt;/packaging&amp;gt;

    &amp;lt;properties&amp;gt;
        &amp;lt;liferay.portal.tools.bundle.support.version&amp;gt;3.7.10&amp;lt;/liferay.portal.tools.bundle.support.version&amp;gt;
        &amp;lt;liferay.bundle.dir&amp;gt;${project.basedir}/bundles&amp;lt;/liferay.bundle.dir&amp;gt;
    &amp;lt;/properties&amp;gt;

    &amp;lt;build&amp;gt;
        &amp;lt;plugins&amp;gt;
            &amp;lt;plugin&amp;gt;
                &amp;lt;groupId&amp;gt;com.liferay&amp;lt;/groupId&amp;gt;
                &amp;lt;artifactId&amp;gt;com.liferay.portal.tools.bundle.support&amp;lt;/artifactId&amp;gt;
                &amp;lt;version&amp;gt;${liferay.portal.tools.bundle.support.version}&amp;lt;/version&amp;gt;
                
                &amp;lt;executions&amp;gt;
                    &amp;lt;!-- Полная очистка перед сборкой новой среды --&amp;gt;
                    &amp;lt;execution&amp;gt;
                        &amp;lt;id&amp;gt;clean-local-bundle&amp;lt;/id&amp;gt;
                        &amp;lt;!-- Привязываем к стандартной фазе clean --&amp;gt;
                        &amp;lt;phase&amp;gt;clean&amp;lt;/phase&amp;gt;
                        &amp;lt;goals&amp;gt;
                            &amp;lt;goal&amp;gt;clean-bundle&amp;lt;/goal&amp;gt;
                        &amp;lt;/goals&amp;gt;
                    &amp;lt;/execution&amp;gt;

                    &amp;lt;!-- Скачивание и разворачивание чистого Liferay Bundle --&amp;gt;
                    &amp;lt;execution&amp;gt;
                        &amp;lt;id&amp;gt;initialize-liferay-server&amp;lt;/id&amp;gt;
                        &amp;lt;!-- Привязываем к фазе инициализации проекта --&amp;gt;
                        &amp;lt;phase&amp;gt;initialize&amp;lt;/phase&amp;gt;
                        &amp;lt;goals&amp;gt;
                            &amp;lt;goal&amp;gt;init-bundle&amp;lt;/goal&amp;gt;
                        &amp;lt;/goals&amp;gt;
                        &amp;lt;configuration&amp;gt;
                            &amp;lt;!-- URL для загрузки дистрибутива --&amp;gt;
                            &amp;lt;bundleURL&amp;gt;your URL&amp;lt;/bundleURL&amp;gt;
                            &amp;lt;!-- Куда распаковывать --&amp;gt;
                            &amp;lt;destDir&amp;gt;${project.basedir}&amp;lt;/destDir&amp;gt;
                        &amp;lt;/configuration&amp;gt;
                    &amp;lt;/execution&amp;gt;

                    &amp;lt;!-- Деплой  --&amp;gt;
                    &amp;lt;execution&amp;gt;
                        &amp;lt;id&amp;gt;deploy-global-configs&amp;lt;/id&amp;gt;
                        &amp;lt;!-- Выполняется на этапе валидации или перед деплоем модулей --&amp;gt;
                        &amp;lt;phase&amp;gt;validate&amp;lt;/phase&amp;gt;
                        &amp;lt;goals&amp;gt;
                            &amp;lt;goal&amp;gt;deploy&amp;lt;/goal&amp;gt;
                        &amp;lt;/goals&amp;gt;
                        &amp;lt;configuration&amp;gt;
                            &amp;lt;bundleDir&amp;gt;${liferay.bundle.dir}&amp;lt;/bundleDir&amp;gt;
                            &amp;lt;!-- Копируем кастомные конфиги --&amp;gt;
                            &amp;lt;configsDir&amp;gt;${project.basedir}/configs/local&amp;lt;/configsDir&amp;gt;
                        &amp;lt;/configuration&amp;gt;
                    &amp;lt;/execution&amp;gt;
                &amp;lt;/executions&amp;gt;
            &amp;lt;/plugin&amp;gt;
        &amp;lt;/plugins&amp;gt;
    &amp;lt;/build&amp;gt;
&amp;lt;/project&amp;gt;
&lt;/pre&gt;

&lt;p style="text-align: justify;"&gt;Кроме того, возможно использование локального бандла (уже собранного), что особенно актуально при использовании Wildfly:&lt;/p&gt;

&lt;pre class="brush:xml;"&gt;
 &amp;lt;configuration&amp;gt;
        &amp;lt;appServerType&amp;gt;wildfly&amp;lt;/appServerType&amp;gt;
        &amp;lt;appServerBundleDir&amp;gt;${project.basedir}/bundles/wildfly&amp;lt;/appServerBundleDir&amp;gt;
        &amp;lt;!-- директория Liferay Home для этого бандла --&amp;gt;
        &amp;lt;liferayHome&amp;gt;${project.basedir}/bundles&amp;lt;/liferayHome&amp;gt;
 &amp;lt;/configuration&amp;gt;&lt;/pre&gt;

&lt;h3 style="text-align: justify;"&gt;2. com.liferay.portal.tools.service.builder&lt;/h3&gt;

&lt;p style="text-align: justify;"&gt;Представляет собой плагин для генерации&amp;nbsp;слоя доступа к данным (Java-классы, интерфейсы, SQL-скрипты, Hibernate/Spring-конфигурации) на основе одного XML-файла описания. Создает интерфейсы и базовые реализации для сервисов, генерирует DDL, обновляет базу и многое другое:&lt;/p&gt;

&lt;pre class="brush:xml;"&gt;
&amp;lt;plugin&amp;gt;
    &amp;lt;groupId&amp;gt;com.liferay&amp;lt;/groupId&amp;gt;
    &amp;lt;artifactId&amp;gt;com.liferay.portal.tools.service.builder&amp;lt;/artifactId&amp;gt;
    &amp;lt;version&amp;gt;1.0.420&amp;lt;/version&amp;gt;
    &amp;lt;executions&amp;gt;
        &amp;lt;execution&amp;gt;
            &amp;lt;id&amp;gt;generate-service&amp;lt;/id&amp;gt;
            &amp;lt;!-- Привязываем генерацию к фазе generate-sources, до компиляции Java --&amp;gt;
            &amp;lt;phase&amp;gt;generate-sources&amp;lt;/phase&amp;gt;
            &amp;lt;goals&amp;gt;
                &amp;lt;goal&amp;gt;build-service&amp;lt;/goal&amp;gt;
            &amp;lt;/goals&amp;gt;
            &amp;lt;configuration&amp;gt;
                &amp;lt;!-- Главный файл с описанием сущностей и базы данных --&amp;gt;
                &amp;lt;inputFile&amp;gt;${project.basedir}/src/main/resources/META-INF/service.xml&amp;lt;/inputFile&amp;gt;
                
                &amp;lt;!-- Куда сгенерируются интерфейсы и DTO --&amp;gt;
                &amp;lt;apiDir&amp;gt;${project.parent.basedir}/my-app-api/src/main/java&amp;lt;/apiDir&amp;gt;
                
                &amp;lt;!-- Куда сгенерируется бизнес-логика и реализация --&amp;gt;
                &amp;lt;implDir&amp;gt;${project.basedir}/src/main/java&amp;lt;/implDir&amp;gt;
                
                &amp;lt;!-- Папка для генерации SQL-скриптов создания таблиц и индексов --&amp;gt;
                &amp;lt;sqlDir&amp;gt;${project.basedir}/src/main/resources/META-INF/sql&amp;lt;/sqlDir&amp;gt;
                
                &amp;lt;!-- Включать ли генерацию REST/JSON веб-сервисов --&amp;gt;
                &amp;lt;buildRemoteService&amp;gt;true&amp;lt;/buildRemoteService&amp;gt;
               
                &amp;lt;!-- Включать ли генерацию локальных Java-сервисов --&amp;gt;
                &amp;lt;buildLocalService&amp;gt;true&amp;lt;/buildLocalService&amp;gt;

            &amp;lt;/configuration&amp;gt;
        &amp;lt;/execution&amp;gt;
    &amp;lt;/executions&amp;gt;
&amp;lt;/plugin&amp;gt;&lt;/pre&gt;

&lt;p style="text-align: justify;"&gt;Чтобы плагин сработал, ему нужен файл конфигурации, где разработчик декларативно описывает сущности базы данных и их связи. Плагин же создает сотни строк сопутствующего кода. Вот минимальный пример файла src/main/resources/META-INF/service.xml для таблицы БД:&lt;/p&gt;

&lt;pre class="brush:xml;"&gt;
&amp;lt;?xml version="1.0" encoding="UTF-8"?&amp;gt;
&amp;lt;!DOCTYPE service-builder PUBLIC "-//Liferay//DTD Service Builder 7.4.0//EN" "http://liferay.com"&amp;gt;

&amp;lt;service-builder dependency-injector="ds" package-path="com.example.myapp"&amp;gt;
    &amp;lt;namespace&amp;gt;MYAPP&amp;lt;/namespace&amp;gt;
    
        &amp;lt;!-- Первичный ключ --&amp;gt;
        &amp;lt;column name="bookId" type="long" primary="true" /&amp;gt;
        
        &amp;lt;!-- Поля таблицы --&amp;gt;
        &amp;lt;column name="title" type="String" /&amp;gt;
        &amp;lt;column name="author" type="String" /&amp;gt;
        &amp;lt;column name="createDate" type="Date" /&amp;gt;
        
        &amp;lt;!-- Индекс для быстрого поиска по автору --&amp;gt;
        &amp;lt;finder name="Author" return-type="Collection"&amp;gt;
            &amp;lt;finder-column name="author" /&amp;gt;
        &amp;lt;/finder&amp;gt;
    
&amp;lt;/service-builder&amp;gt;
&lt;/pre&gt;

&lt;h3 style="text-align: justify;"&gt;3. com.liferay.portal.tools.rest.builder&lt;/h3&gt;

&lt;p style="text-align: justify;"&gt;Представляет собой плагин для генерации API&amp;nbsp;(эндпоинты, схемы запросов/ответов). Разработчик описывает&amp;nbsp;контракт своего API в стандартном формате OpenAPI (YAML), а плагин автоматически генерирует JAX-RS эндпоинты, DTO-модели, валидацию и Jackson-маппинг. Разработчику остаётся только написать бизнес-логику в классах реализации. Кроме того, плагин автоматически разворачивает эндпоинты в интерфейсе Swagger UI портала, делая API доступным для тестирования фронтенд-разработчиками сразу после деплоя бандла. Подключается так:&lt;/p&gt;

&lt;pre class="brush:xml;"&gt;
&amp;lt;plugin&amp;gt;
    &amp;lt;groupId&amp;gt;com.liferay&amp;lt;/groupId&amp;gt;
    &amp;lt;artifactId&amp;gt;com.liferay.portal.tools.rest.builder&amp;lt;/artifactId&amp;gt;
    &amp;lt;version&amp;gt;1.0.475&amp;lt;/version&amp;gt;
    &amp;lt;executions&amp;gt;
        &amp;lt;execution&amp;gt;
            &amp;lt;id&amp;gt;generate-headless-api&amp;lt;/id&amp;gt;
            &amp;lt;phase&amp;gt;generate-sources&amp;lt;/phase&amp;gt;
            &amp;lt;goals&amp;gt;
                &amp;lt;goal&amp;gt;build&amp;lt;/goal&amp;gt;
            &amp;lt;/goals&amp;gt;
            &amp;lt;configuration&amp;gt;
                &amp;lt;!-- Базовая папка, где лежат YAML схемы (rest-config.yaml, rest-openapi.yaml) --&amp;gt;
                &amp;lt;baseDir&amp;gt;${project.basedir}&amp;lt;/baseDir&amp;gt;
                
                &amp;lt;!-- Относительный путь к подмодулю API, куда попадут сгенерированные интерфейсы --&amp;gt;
                &amp;lt;apiDir&amp;gt;../my-headless-api/src/main/java&amp;lt;/apiDir&amp;gt;
                
                &amp;lt;!-- Путь в текущем модуле, куда попадет реализация REST --&amp;gt;
                &amp;lt;implDir&amp;gt;src/main/java&amp;lt;/implDir&amp;gt;
            &amp;lt;/configuration&amp;gt;
        &amp;lt;/execution&amp;gt;
    &amp;lt;/executions&amp;gt;
&amp;lt;/plugin&amp;gt;&lt;/pre&gt;

&lt;p style="text-align: justify;"&gt;Для генерации API требуются два файла в модуле:&lt;/p&gt;

&lt;ul&gt;
	&lt;li style="text-align: justify;"&gt;rest-openapi.yaml -- стандартное описание путей, методов (GET/POST/PUT) и моделей данных по спецификации OpenAPI 3.0.&lt;/li&gt;
&lt;/ul&gt;

&lt;pre class="brush:as3;"&gt;
openapi: 3.0.0
info:
  title: "My Custom API"
  version: v1.0
paths:
  /todos:
    get:
      operationId: getTodosPage
      description: "Получить список задач"
      responses:
        200:
          description: "Успешный ответ"
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: "#/components/schemas/Todo"
components:
  schemas:
    Todo:
      type: object
      properties:
        id:
          type: integer
          format: int64
        title:
          type: string
        completed:
          type: boolean
&lt;/pre&gt;

&lt;ul&gt;
	&lt;li style="text-align: justify;"&gt;rest-config.yaml -- служебный файл Liferay, задает метаданные плагина, включая базовые пакеты, автора и системный контекст для OSGi:&lt;/li&gt;
&lt;/ul&gt;

&lt;pre class="brush:as3;"&gt;
apiPackagePath: "com.example.headless.api"
author: "Liferay Developer"
clientDir: "../my-headless-client/src/main/java" # если нужен клиент
compatibilityVersion: "7.4.0"
implPackagePath: "com.example.headless.internal"
jaxRsApplicationBaseUri: "/my-custom-api"
jaxRsApplicationName: "MyCustomAPI"&lt;/pre&gt;

&lt;h3 style="text-align: justify;"&gt;4. com.liferay.css.builder&lt;/h3&gt;

&lt;p style="text-align: justify;"&gt;Представляет собой плагин,&amp;nbsp;который компилирует файлы стилей Sass (.scss) в стандартный CSS.&amp;nbsp;В экосистеме Liferay этот плагин критически важен при сборке кастомных тем оформления, а также при стилизации отдельных портлетов и UI-компонентов. Он автоматически подтягивает глобальные стили ядра Liferay, обрабатывает импорты, миксины, переменные и минифицирует итоговый код. То есть&amp;nbsp;CSS Builder предстает как Java-обертка над компилятором Sass, полностью интегрированная в сборочные контейнеры Gradle и Maven. Подключение на примере Maven:&lt;/p&gt;

&lt;pre class="brush:xml;"&gt;
&amp;lt;plugin&amp;gt;
    &amp;lt;groupId&amp;gt;com.liferay&amp;lt;/groupId&amp;gt;
    &amp;lt;artifactId&amp;gt;com.liferay.css.builder&amp;lt;/artifactId&amp;gt;
    &amp;lt;version&amp;gt;3.1.2&amp;lt;/version&amp;gt;
    &amp;lt;executions&amp;gt;
        &amp;lt;execution&amp;gt;
            &amp;lt;id&amp;gt;compile-sass-to-css&amp;lt;/id&amp;gt;
            &amp;lt;!-- Привязываем компиляцию стилей к фазе генерации ресурсов --&amp;gt;
            &amp;lt;phase&amp;gt;generate-resources&amp;lt;/phase&amp;gt;
            &amp;lt;goals&amp;gt;
                &amp;lt;goal&amp;gt;build&amp;lt;/goal&amp;gt;
            &amp;lt;/goals&amp;gt;
            &amp;lt;configuration&amp;gt;
                &amp;lt;!-- Директория, где лежат исходные файлы .scss --&amp;gt;
                &amp;lt;docRootDir&amp;gt;${project.basedir}/src/main/resources/META-INF/resources&amp;lt;/docRootDir&amp;gt;
                
                &amp;lt;!-- Подкаталог внутри docRootDir, где непосредственно искать .scss файлы --&amp;gt;
                &amp;lt;inputDir&amp;gt;/&amp;lt;/inputDir&amp;gt;
                
                &amp;lt;!-- Куда складывать скомпилированные .css файлы --&amp;gt;
                &amp;lt;outputDir&amp;gt;/&amp;lt;/outputDir&amp;gt;
                
                &amp;lt;!-- Включать ли генерацию Source Maps для удобной отладки в браузере --&amp;gt;
                &amp;lt;generateSourceMap&amp;gt;true&amp;lt;/generateSourceMap&amp;gt;
                
                &amp;lt;!-- Стили, которые нужно исключить из прямой компиляции  --&amp;gt;
                &amp;lt;compilerExcludes&amp;gt;**/_*.scss&amp;lt;/compilerExcludes&amp;gt;
                
                &amp;lt;!-- Пути к сторонним Sass-библиотекам или темам --&amp;gt;
                &amp;lt;importPaths&amp;gt;
                    &amp;lt;importPath&amp;gt;${project.basedir}/src/main/resources/META-INF/resources/node_modules&amp;lt;/importPath&amp;gt;
                &amp;lt;/importPaths&amp;gt;
            &amp;lt;/configuration&amp;gt;
        &amp;lt;/execution&amp;gt;
    &amp;lt;/executions&amp;gt;
&amp;lt;/plugin&amp;gt;&lt;/pre&gt;

&lt;h3 style="text-align: justify;"&gt;Итог&lt;/h3&gt;

&lt;p style="text-align: justify;"&gt;В заключение отметим, что комбинация этих четырех плагинов закрывает базовые потребности команды разработки, обеспечивая автоматизацию проекта на всех уровнях: от инфраструктурного слоя до баз данных, сетевых интерфейсов и визуального отображения.&lt;/p&gt;</summary>
    <dc:creator>Никита Рогаленко</dc:creator>
    <dc:date>2026-09-07T15:36:00Z</dc:date>
  </entry>
  <entry>
    <title>Введение в архитектуру ПО. Часть 2: Три парадигмы и сила ограничений</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21301163" />
    <author>
      <name>Romo Fedoroff</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21301163</id>
    <updated>2026-09-02T02:20:28Z</updated>
    <published>2026-09-02T02:00:00Z</published>
    <summary type="html">&lt;style type="text/css"&gt;

article p {
font-size:11pt;
font-family:Verdana, sans-serif;
text-align:justify;
color:#6a6a6a;
}

article img {
width: 90%;
}

article li {
 font-size:11pt;   
}

.centered {
text-align:center;
}


article .portlet-msg-info {
color: #232323;
background-color: #f9f9f9;
border-style: dashed;
border-color: #232323;
}

&lt;/style&gt;
&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Введение&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;В первой части мы говорили о том, что архитектура - это не про изощрённые решения, а про стоимость изменений. Про то, почему спешка на старте оборачивается неделями работы там, где раньше хватало дня, и как обсуждать всё это с руководством так, чтобы вас услышали.&lt;/p&gt;

&lt;p&gt;Но у любого разговора об архитектуре есть неудобный момент. Рано или поздно кто-то спрашивает: хорошо, я согласен, что нужна низкая связанность и высокая согласованность - а как именно её получить? Что конкретно я должен делать завтра утром, открыв редактор?&lt;/p&gt;

&lt;p&gt;Ответ начинается гораздо ниже уровня диаграмм и слоёв. Он начинается в коде.&lt;/p&gt;

&lt;p&gt;Архитектура не существует отдельно от кода - она из него собирается. Границы между компонентами проводятся не в документации, а вызовами функций и объявлениями интерфейсов. Поэтому, прежде чем обсуждать принципы проектирования и паттерны, стоит разобраться с тем, из чего вообще состоит наш инструментарий. А состоит он из трёх парадигм программирования, каждая из которых была открыта более полувека назад и с тех пор не менялась.&lt;/p&gt;

&lt;p&gt;Самое интересное в них - то, как именно они работают. Не так, как обычно предполагают.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Немного истории: как программы стали данными&lt;/h2&gt;

&lt;p&gt;Основы того, чем мы занимаемся каждый день, заложил Алан Тьюринг. Программируемые машины придумывали и до него, но именно Тьюринг в 1938 году сформулировал ключевую идею: программа - это данные. Не особая сущность, не механизм, а обычная информация, которую можно хранить, передавать и обрабатывать так же, как любую другую.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;К середине 1940-х он уже писал программы для реальных машин. И если сегодня посмотреть на его код, мы, приложив некоторое усилие, его прочитаем: там есть циклы, ветвления, присваивания, подпрограммы, стеки. Всё то же самое, чем мы пользуемся сейчас. Разница в том, что записывалось это двоичным кодом.&lt;/p&gt;

&lt;p&gt;Дальше история пошла быстро. В конце 1940-х появились ассемблеры - они избавили программистов от ручного перевода инструкций в машинные коды. В 1951 году Грейс Хоппер создала первый компилятор A-0 и ввела в оборот сам термин «компилятор». В 1953 году появился Fortran, за ним COBOL, PL/I, C, Pascal, C++, Java - и далее непрерывным потоком до сегодняшнего дня.&lt;/p&gt;

&lt;p&gt;Революция языков видна всем: о ней спорят на конференциях, из-за неё меняют место работы, ей посвящены бесконечные сравнительные таблицы. Но была и вторая революция, куда менее заметная и, если честно, куда более важная для архитектуры. Революция парадигм.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Что такое парадигма и почему это не то же самое, что язык&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Парадигма - это способ программирования, не привязанный к конкретному языку. Она определяет, какие конструкции вы используете и, что важнее, каких избегаете.&lt;/p&gt;

&lt;p&gt;Разницу между языком и парадигмой легко почувствовать на практике. Можно писать вполне объектно-ориентированный код на чистом C - через структуры и таблицы указателей на функции, именно так устроены многие драйверы и ядро Linux. И точно так же можно писать на Java или C# в откровенно процедурном стиле: класс с одним статическим методом на тысячу строк - это не объектно-ориентированное программирование, сколько бы ключевых слов из учебника там ни встретилось.&lt;/p&gt;

&lt;p&gt;Язык - это набор возможностей. Парадигма - это дисциплина их применения.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Для тех, кто только начинает:&lt;/strong&gt; представьте, что вам выдали полный набор столярных инструментов. Язык - это то, какие именно инструменты лежат в ящике. Парадигма - это принятая в мастерской практика: например, никогда не забивать шурупы молотком, даже если это быстрее и физически возможно. Инструмент никуда не делся, вы просто договорились им так не пользоваться.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Для тех, у кого есть опыт&lt;/strong&gt;: отсюда следует практический вывод. Переход на новый язык сам по себе не улучшает архитектуру. Команда, писавшая запутанный код на PHP, напишет ровно такой же запутанный код на Go или Kotlin, если не поменяется дисциплина. Меняет ситуацию не синтаксис, а то, от чего команда сознательно отказалась.&lt;/p&gt;

&lt;p&gt;Всего парадигм три: структурное программирование, объектно-ориентированное и функциональное. И у них есть общая особенность, которую редко замечают.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Главный парадокс: парадигмы ничего не дают&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Присмотритесь к тому, что делает каждая из трёх парадигм.&lt;/p&gt;

&lt;p&gt;Структурное программирование ограничивает прямую передачу управления - забирает у нас безусловные переходы.&lt;/p&gt;

&lt;p&gt;Объектно-ориентированное программирование ограничивает косвенную передачу управления - забирает свободное обращение с указателями на функции.&lt;/p&gt;

&lt;p&gt;Функциональное программирование ограничивает присваивание - забирает возможность менять значение в любой момент.&lt;/p&gt;

&lt;p&gt;Ни одна из них не добавляет новой выразительной мощности. Ни одна не позволяет написать программу, которую нельзя было написать раньше. Каждая только отнимает.&lt;/p&gt;

&lt;p&gt;Это звучит контринтуитивно, но именно в этом их ценность. Парадигмы говорят нам не столько что делать, сколько чего не делать. Они сужают пространство возможных решений - и тем самым делают код предсказуемым.&lt;/p&gt;

&lt;p&gt;Аналогия здесь простая. Правила дорожного движения не расширяют возможности автомобиля: он и без них способен ехать по встречной полосе. Правила именно что запрещают, и благодаря этому дорожное движение вообще существует как система, а не как набор случайных траекторий. Ценность ограничения - в предсказуемости, которую оно создаёт для всех остальных участников.&lt;/p&gt;

&lt;p&gt;В коде происходит то же самое. Когда я открываю незнакомый модуль, написанный в рамках знакомой мне дисциплины, я заранее знаю, чего там точно не будет. Не будет прыжка из середины одной функции в середину другой. Не будет тихой мутации объекта, который я передал третьей стороне. Это резко снижает объём того, что мне нужно держать в голове - ту самую когнитивную нагрузку, о которой шла речь в первой части.&lt;/p&gt;

&lt;p&gt;Обратите внимание и на исторический факт: все три парадигмы были открыты в промежутке примерно между 1958 и 1968 годами. За прошедшие с тех пор десятилетия не появилось ни одной новой. И это, скорее всего, не случайность: отнимать больше нечего. Три парадигмы забрали переходы, свободные указатели на функции и неограниченное присваивание - то есть все три способа, которыми программа может выйти из-под контроля.&lt;/p&gt;

&lt;p&gt;Разберём каждую подробно. В этой части мы остановимся на первой - структурном программировании. Она кажется самой очевидной и именно поэтому чаще всего применяется формально, без понимания сути.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Структурное программирование: как один спор изменил профессию&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Эдсгер Вибе Дейкстра родился в Роттердаме в 1930 году, пережил бомбардировки города и оккупацию Нидерландов, а в 1948 году окончил школу с лучшими оценками по математике, физике, химии и биологии. В 1952 году, в двадцать один год, он устроился в Математический центр Амстердама и стал, по сути, первым программистом в стране.&lt;/p&gt;

&lt;p&gt;Есть один эпизод, который хорошо передаёт дух той эпохи. В 1957 году Дейкстра женился, а голландские правила того времени требовали указать в документах профессию. Он написал «программист» - и документы не приняли, потому что о такой профессии никто не слышал. Пришлось указать «физик-теоретик».&lt;/p&gt;

&lt;p&gt;Работал он в условиях, которые сегодня трудно вообразить: ламповые машины, ввод программ с перфокарт, цикл «правка - компиляция - проверка» длиной в часы, а иногда и в сутки. Ошибка стоила дорого не в переносном смысле, а в самом прямом: день работы.&lt;/p&gt;

&lt;p&gt;Именно в такой среде Дейкстра сформулировал наблюдение, которое до сих пор определяет нашу профессию. Программирование - слишком сложная работа для человеческого мозга без вспомогательной дисциплины. В программе любого практического размера деталей больше, чем человек способен удержать. Достаточно упустить одну - и код, который выглядит работающим, откажет в самом неожиданном месте.&lt;/p&gt;

&lt;p&gt;Дейкстра искал способ доказывать правильность программ математически - выстроить для кода что-то вроде евклидовой иерархии из аксиом, теорем и следствий. В процессе он обнаружил интересную вещь.&lt;/p&gt;

&lt;p&gt;Неограниченные переходы - инструкция goto - ломали саму возможность такого доказательства. Когда управление может прыгнуть в произвольную точку, программу невозможно разложить на независимые части: каждый фрагмент связан со всеми остальными непредсказуемым образом. Принцип «разделяй и властвуй» перестаёт работать.&lt;/p&gt;

&lt;p&gt;Но не все переходы вели себя так. Дейкстра заметил, что «безвредные» случаи применения goto укладываются в несколько простых схем - те, что мы знаем как if/then/else и do/while. Модули, построенные только на таких конструкциях, разбирались на доказуемые части без проблем.&lt;/p&gt;

&lt;p&gt;И тут сошлись две линии. Двумя годами ранее Коррадо Бём и Джузеппе Якопини доказали теорему: любую программу можно записать, используя всего три конструкции - последовательность, выбор и итерацию. То есть минимальный набор, достаточный для написания чего угодно, в точности совпал с набором конструкций, при которых код остаётся анализируемым.&lt;/p&gt;

&lt;p&gt;Так родилось структурное программирование.&lt;/p&gt;

&lt;p&gt;В 1968 году Дейкстра опубликовал в журнале CACM своё знаменитое письмо о вреде оператора goto, и профессиональное сообщество взорвалось. Спор шёл около десяти лет - с письмами в редакции, резкими возражениями и не менее резкой поддержкой. Закончился он тем, что Дейкстра просто победил: языки эволюционировали, goto постепенно исчез, и сегодня большинство языков его либо не имеет вовсе, либо жёстко ограничивает границами одной функции.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h3&gt;Как это выглядит на практике&lt;/h3&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Вот фрагмент в духе того кода, против которого Дейкстра выступал. Псевдокод намеренно упрощён:&lt;/p&gt;

&lt;pre class="brush:cpp;"&gt;
 i = 0;
    total = 0;
loop:
    if (i &amp;gt;= n) goto done;
    if (items[i].valid == 0) goto next;
    if (items[i].amount &amp;lt; 0) goto error;
    total = total + items[i].amount;
next:
    i = i + 1;
    goto loop;
error:
    log("bad amount");
    goto next;
done:
    return total;&lt;/pre&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Формально здесь всё работает. Но попробуйте ответить на вопрос: при каких условиях управление попадает на метку next? Придётся глазами просканировать весь фрагмент в поисках всех переходов. А в реальном коде тех лет такой фрагмент занимал не пятнадцать строк, а несколько сотен.&lt;/p&gt;

&lt;p&gt;То же самое в структурном виде:&lt;/p&gt;

&lt;pre class="brush:cpp;"&gt;
int total = 0;
for (int i = 0; i &amp;lt; n; i++) {
    if (!items[i].valid) {
        continue;
    }
    if (items[i].amount &amp;lt; 0) {
        log("bad amount");
        continue;
    }
    total += items[i].amount;
}
return total;
&lt;/pre&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Разница не в количестве строк - оно почти одинаковое. Разница в том, что теперь у фрагмента есть чёткая граница. Я вижу тело цикла целиком и знаю: управление войдёт сюда сверху и выйдет снизу, других вариантов нет. Мне не нужно проверять, не прыгает ли сюда кто-то ещё из соседнего модуля.&lt;/p&gt;

&lt;p&gt;Именно это свойство и есть суть парадигмы: у каждого блока кода один вход и один выход.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h3&gt;Современный goto, который никто так не называет&lt;/h3&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Вот здесь начинается самое важное, и об этом обычно молчат. Считается, что тема закрыта: goto в языке нет, значит, структурное программирование соблюдается автоматически. Это не так.&lt;/p&gt;

&lt;p&gt;Ключевое слово исчезло, а само явление - нет. Неограниченная передача управления просто сменила форму. Вот несколько её современных обличий, которые я регулярно встречаю в рабочих проектах.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h3&gt;Исключения как штатный поток управления&lt;/h3&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Когда исключение бросается не при аварии, а как обычный способ вернуть результат из глубины стека вызовов - это ровно тот же прыжок в неизвестное место, только легализованный синтаксисом:&lt;/p&gt;

&lt;pre class="brush:jscript;"&gt;
function findDiscount(user) {
  if (user.isVip) {
    throw new DiscountFound(0.2);   // это не ошибка, это возврат значения
  }
  // ...
}&lt;/pre&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Читатель функции findDiscount не может понять по её сигнатуре, что она вообще-то возвращает результат таким способом. Обработчик находится где-то на три уровня выше по стеку. Это метка goto, до которой сорок минут поиска по проекту.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h3&gt;Флаги состояния, управляющие ходом выполнения&lt;/h3&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Классика:&lt;/p&gt;

&lt;pre class="brush:jscript;"&gt;
let shouldSkip = false;
let hasError = false;

for (const order of orders) {
  if (hasError) { break; }
  if (shouldSkip) { shouldSkip = false; continue; }
  // сто строк логики, где-то внутри которой
  // выставляются shouldSkip и hasError
}&lt;/pre&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Формально здесь только for, if, break и continue. Фактически - конечный автомат, спрятанный в переменных, и предсказать его поведение можно только выполнением в голове.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h3&gt;Глубокая вложенность&lt;/h3&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Она не нарушает правил формально, но убивает то самое свойство «один вход, один выход», ради которого всё затевалось:&lt;/p&gt;

&lt;pre class="brush:jscript;"&gt;
function handleOrder(order) {
  if (order) {
    if (order.items.length &amp;gt; 0) {
      if (order.customer.isActive) {
        if (hasStock(order)) {
          if (paymentAllowed(order)) {
            // основная логика прячется здесь, на шестом уровне
          }
        }
      }
    }
  }
}&lt;/pre&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Хорошая новость в том, что лечится это одинаково - декомпозицией и ранними возвратами:&lt;/p&gt;

&lt;pre class="brush:jscript;"&gt;
function handleOrder(order) {
  const violation = validateOrder(order);
  if (violation) {
    return Result.rejected(violation);
  }

  reserveStock(order);
  return Result.accepted(createInvoice(order));
}

function validateOrder(order) {
  if (!order.items.length)        return 'EMPTY_ORDER';
  if (!order.customer.isActive)   return 'INACTIVE_CUSTOMER';
  if (!hasStock(order))           return 'OUT_OF_STOCK';
  if (!paymentAllowed(order))     return 'PAYMENT_BLOCKED';
  return null;
}&lt;/pre&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Функция handleOrder теперь читается за пять секунд и умещается на экране целиком. Проверки собраны в одном месте, и добавление новой не требует трогать основной сценарий. Это ровно та низкая связанность и высокая согласованность, о которых мы говорили в первой части - только выраженная не в терминах модулей, а в терминах пяти строк кода.&lt;/p&gt;

&lt;p&gt;Практический ориентир, который я советую держать в голове: если функция не помещается на один экран без прокрутки или содержит больше трёх-четырёх уровней вложенности - это сигнал, а не приговор. Обычно за таким фрагментом скрываются две-три самостоятельные операции, которые просто ещё не получили имён.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Функциональная декомпозиция: почему это работает&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Из структурного программирования следует важное практическое свойство - возможность рекурсивно разбивать программу на части.&lt;/p&gt;

&lt;p&gt;Большая задача раскладывается на несколько функций верхнего уровня. Каждая из них - на функции уровнем ниже. И так далее, пока не дойдём до фрагментов, которые целиком укладываются в голову. Именно на этом фундаменте в конце 1970-х и в 1980-х выросли дисциплины структурного анализа и структурного проектирования, которые продвигали Эд Йордан, Ларри Константин, Том Демарко и Меилир Пейдж-Джонс.&lt;/p&gt;

&lt;p&gt;Работает это не потому, что мелкие функции - это красиво. А потому, что у каждой части появляется определённый контракт: что она принимает на входе, что возвращает на выходе. Пока управление входит в блок только сверху и покидает его только снизу, такой контракт существует. Как только появляется свободный переход - контракта нет, и рассуждать о части в отрыве от целого больше невозможно.&lt;/p&gt;

&lt;p&gt;Простой пример из практики. Функция расчёта стоимости заказа на четыреста строк - это одно утверждение, которое либо верно, либо нет, и проверить его можно только целиком. Та же логика, разложенная на расчёт базовой суммы, применение скидок, начисление налога и учёт доставки - это четыре независимых утверждения. Каждое проверяется отдельно, и при ошибке в итоговой сумме вы сразу знаете, где искать.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Для специалистов с опытом&lt;/strong&gt;: отсюда же растёт и практическая ценность метрики цикломатической сложности. Она измеряет количество независимых путей исполнения через функцию - то есть, по сути, количество случаев, которые придётся разобрать, чтобы убедиться в её правильности. Это не абстрактный показатель для отчётности, а прямая оценка того, сколько усилий потребует проверка кода. Функцию со сложностью 3 держит в голове любой; функцию со сложностью 25 не держит никто, включая её автора через две недели после написания.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Доказательства, которых не случилось&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;У истории структурного программирования есть неожиданный финал, и он важнее самой истории.&lt;/p&gt;

&lt;p&gt;Мечта Дейкстры не сбылась. Евклидову иерархию доказанных теорем для программ так и не построили. Формальное доказательство правильности каждой функции оказалось настолько трудоёмким, что практическая индустрия от него отказалась. Сегодня формальная верификация применяется, но в узких областях, где цена ошибки исключительна: авионика, медицинское оборудование, криптографические примитивы. В обычной разработке её нет.&lt;/p&gt;

&lt;p&gt;Но отказ от доказательств не означал отказа от строгости. Просто строгость пришла из другой дисциплины.&lt;/p&gt;

&lt;p&gt;Разница между математикой и наукой принципиальна. Математика доказывает истинность утверждений. Наука так не умеет: невозможно доказать второй закон Ньютона. Можно провести множество экспериментов, измерить результат с любой точностью, но всегда остаётся вероятность, что следующий эксперимент покажет границы применимости закона - собственно, с ньютоновской механикой ровно это и произошло.&lt;/p&gt;

&lt;p&gt;Наука работает наоборот: она пытается опровергнуть. Утверждение, которое устояло после множества добросовестных попыток его опровергнуть, мы считаем истинным - до тех пор, пока не появится опровержение.&lt;/p&gt;

&lt;p&gt;Разработка программного обеспечения устроена по научному принципу, а не по математическому. И у Дейкстры есть на этот счёт афоризм, который стоит помнить любому, кто пишет тесты: «Тестирование показывает присутствие ошибок, а не их отсутствие».&lt;/p&gt;

&lt;p&gt;Тестами нельзя доказать, что программа правильная. Можно доказать только обратное - что она неправильная. Всё, что даёт нам зелёная сборка после достаточных усилий, - это обоснованная уверенность в том, что программа работает достаточно правильно для наших целей.&lt;/p&gt;

&lt;p&gt;И вот здесь замыкается вся логика этой части. Опровергать можно только то, что поддаётся разбору на части. Программу, в которой управление скачет произвольным образом, нельзя признать правильной ни при каком количестве тестов, потому что вы не можете изолировать проверяемое утверждение. Структурное программирование нужно нам ровно для того, чтобы получить тестируемые единицы.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h3&gt;Тестируемость - это архитектурное свойство&lt;/h3&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Из сказанного следует вывод, который стоит отдельного разговора: если что-то трудно протестировать, проблема почти никогда не в тестах. Проблема в структуре.&lt;/p&gt;

&lt;p class="brush:jscript;"&gt;Посмотрите на функцию, которая на первый взгляд не вызывает вопросов:&lt;/p&gt;

&lt;pre class="brush:jscript;"&gt;
function isSubscriptionExpired(userId) {
  const user = db.query('SELECT * FROM users WHERE id = ?', userId);
  return user.expires_at &amp;lt; new Date();
}&lt;/pre&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Здесь три строки и одна простая мысль. Но чтобы её проверить, нужна база данных с подготовленными записями, а ещё нужно как-то подменить системное время - иначе тест на «подписка истекает завтра» сломается ровно завтра. В итоге вокруг трёх строк вырастает инфраструктура на сотню строк, которая работает медленно и ломается по не связанным с логикой причинам.&lt;/p&gt;

&lt;p&gt;Теперь то же самое, но с разделением решения и получения данных:&lt;/p&gt;

&lt;pre class="brush:jscript;"&gt;
// Чистая функция: решение. Никаких обращений вовне.
function isSubscriptionExpired(expiresAt, now) {
  return expiresAt &amp;lt; now;
}

// Оболочка: получение данных и побочные эффекты.
async function checkUserSubscription(userId, clock) {
  const user = await users.findById(userId);
  return isSubscriptionExpired(user.expiresAt, clock.now());
}&lt;/pre&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Проверка решения теперь не требует ничего:&lt;/p&gt;

&lt;pre class="brush:jscript;"&gt;
test('подписка считается истёкшей на следующий день после даты окончания', () =&amp;gt; {
  const expiresAt = new Date('2026-01-01T00:00:00Z');
  const now       = new Date('2026-01-02T00:00:00Z');

  expect(isSubscriptionExpired(expiresAt, now)).toBe(true);
});&lt;/pre&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Ни базы, ни моков, ни зависимости от календаря. Тест выполняется за доли миллисекунды и падает только тогда, когда логика действительно сломана.&lt;/p&gt;

&lt;p&gt;Заметьте, что мы сделали. Мы не «написали тесты» - мы изменили структуру кода так, чтобы его вообще было о чём спрашивать. Время и база данных превратились из скрытых зависимостей в явные параметры. Это ровно то, чем занимается архитектор, только в масштабе одной функции: отделяет то, что решает, от того, что общается с внешним миром.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Практический признак для команды&lt;/strong&gt;: если в проекте регулярно звучит фраза «это невозможно нормально протестировать», у вас не проблема с тестированием. У вас диагноз архитектуры, и он бесплатный - его выдали вам сами тесты.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Что из этого следует для архитектуры&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Может показаться, что мы ушли далеко в сторону от темы. На самом деле нет: три парадигмы напрямую соответствуют трём опорам архитектуры.&lt;/p&gt;

&lt;p&gt;Структурное программирование даёт алгоритмическую основу для модулей - оно отвечает за функциональность и за то, что каждый модуль можно проверить по отдельности.&lt;/p&gt;

&lt;p&gt;Объектно-ориентированное программирование через полиморфизм даёт механизм пересечения архитектурных границ - оно отвечает за разделение компонентов и за возможность менять реализацию, не трогая тех, кто ею пользуется.&lt;/p&gt;

&lt;p&gt;Функциональное программирование накладывает ограничения на то, где живут данные и кто имеет право их менять - оно отвечает за управление состоянием.&lt;/p&gt;

&lt;p&gt;Функциональность, разделение компонентов, управление данными. Три парадигмы, три опоры, никаких совпадений.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Заключение&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Если собрать главное из этого материала, получится следующее.&lt;/p&gt;

&lt;p&gt;Парадигмы - это не про то, что язык вам позволяет, а про то, от чего вы сознательно отказались. Смена языка не улучшает архитектуру; меняет ситуацию только смена дисциплины.&lt;/p&gt;

&lt;p&gt;Каждая из трёх парадигм ограничивает, а не расширяет. Ценность ограничения - в предсказуемости: читая код, вы заранее знаете, чего в нём не будет, и это экономит вам главный ресурс - внимание.&lt;/p&gt;

&lt;p&gt;Отсутствие ключевого слова goto в языке не означает соблюдения структурного программирования. Исключения в роли возврата значений, флаги-переключатели и глубокая вложенность создают ровно ту же проблему, ради решения которой всё затевалось.&lt;/p&gt;

&lt;p&gt;Функциональная декомпозиция ценна не сама по себе, а тем, что превращает одно большое непроверяемое утверждение в набор маленьких проверяемых.&lt;/p&gt;

&lt;p&gt;Разработка ближе к науке, чем к математике. Мы не доказываем правильность - мы не смогли доказать неправильность и считаем это достаточным основанием. Отсюда и роль тестов: они не гарантия, а инструмент опровержения.&lt;/p&gt;

&lt;p&gt;Трудность тестирования - это не свойство тестов, а свойство архитектуры. Если что-то невозможно проверить без поднятия половины системы, проблема находится в коде, а не в инструментах.&lt;/p&gt;

&lt;p&gt;Спасибо, что дочитали до конца.&lt;/p&gt;

&lt;p&gt;В следующей части мы разберём вторую парадигму - объектно-ориентированное программирование. Поговорим о том, чем оно на самом деле является, почему полиморфизм оказался главным архитектурным изобретением за пятьдесят лет и как с его помощью развернуть направление зависимостей между модулями в нужную сторону.&lt;/p&gt;

&lt;p&gt;Следите за продолжением.&lt;/p&gt;</summary>
    <dc:creator>Romo Fedoroff</dc:creator>
    <dc:date>2026-09-02T02:00:00Z</dc:date>
  </entry>
  <entry>
    <title>Spring event bus. Гарантия выполнения метода после коммита транзакции.</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21290221" />
    <author>
      <name>Maxim Kalabukhov</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21290221</id>
    <updated>2026-08-07T18:52:24Z</updated>
    <published>2026-08-07T18:39:00Z</published>
    <summary type="html">&lt;p&gt;Сегодня коротко поговорим про Spring Event Bus и разберем одну&amp;nbsp;задачку.&lt;/p&gt;

&lt;p&gt;Недавно столкнулся с ситуацией - есть некий общий функционал, который вызывается из совершенно разных роутов. Сами роуты обернуты в транзакцию. Сообщение (ивент) в брокер об успешном выполнении этого общего функционала нужно отправлять прямо внутри этого небольшого метода. Но чтобы всё отработало безопасно, ивент должен улетать только после коммита транзакции.&lt;/p&gt;

&lt;p&gt;Конечно, первым на ум приходит запихивание отправки ивента в конец каждого верхнего роута. А хотелось бы просто опубликовать событие локально и быть уверенным, что оно улетит после успешного коммита внешней транзакции, кем бы она ни открывалась. И Spring event bus вместе с аннотацией &lt;code&gt;@TransactionalEventListener&lt;/code&gt; дают возможное решение данной ситуации.&lt;/p&gt;

&lt;p&gt;Шина событий в Spring - это такой встроенный publisher/subscriber внутри одного приложения: какой-то компонент системы может отправить событие в шину, а настроенные слушатели обработают его заданным образом.&lt;/p&gt;

&lt;p&gt;Создать событие в Kotlin можно проще простого, обычным &lt;code&gt;data class&lt;/code&gt;:&lt;/p&gt;

&lt;pre&gt;
data class ActionCompletedEvent(
    val entityId: Long,
    val payload: String
)&lt;/pre&gt;

&lt;p dir="auto"&gt;В сервисе мы публикуем событие ровно там, где оно должно происходить по логике, и забываем про него. Публикуется оно, кстати, через &lt;code&gt;ApplicationEventPublisher&lt;/code&gt;:&lt;/p&gt;

&lt;pre&gt;
@Service
class SomeService(
    private val someRepository: SomeRepository,
    private val eventPublisher: ApplicationEventPublisher
) {

    // Метод вызывается из разных транзакционных роутов
    fun performAction(entity: Entity, payload: String) {
        someRepository.save(...)
        // Публикуем событие локально. 
        // Что будет дальше - нас не волнует.
        eventPublisher.publishEvent(ActionCompletedEvent(entity.id, payload))
    }
}&lt;/pre&gt;

&lt;p dir="auto"&gt;Если мы в слушателе повесим обычный &lt;code&gt;@EventListener&lt;/code&gt;, он сработает прямо в момент вызова &lt;code&gt;publishEvent&lt;/code&gt;. То есть проблема с откатом транзакции останется -&amp;nbsp; ивент улетит до того, как внешняя транзакция подтвердит сохранение. Но у Spring есть &lt;code&gt;@TransactionalEventListener&lt;/code&gt;:&lt;/p&gt;

&lt;pre&gt;
@Component
class ActionListener(
    private val kafka: kafkaClient
) {

    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    fun handleActionCompleted(event: ActionCompletedEvent) {
        // Этот код выполнится ТОЛЬКО после успешного коммита в БД.
        // Spring сам поймет, к какой внешней транзакции мы привязаны.
        kafka.sendEvent(event.entityId, event.payload)
    }
}&lt;/pre&gt;

&lt;p dir="auto"&gt;Видите фазу &lt;code&gt;AFTER_COMMIT&lt;/code&gt;? Spring сам отслеживает контекст транзакции. Мы можем легально вызывать &lt;code&gt;publishEvent&lt;/code&gt; в любом месте метода, сохраняя правильную семантику кода. А Spring гарантирует, что слушатели отработают только после успешного коммита самой верхней транзакции в стеке вызовов. Если что-то упадет и транзакция откатится, событие просто игнорируется.&lt;/p&gt;

&lt;p dir="auto"&gt;Единственный нюанс при использовании - это то, что по умолчанию &lt;code&gt;@TransactionalEventListener&lt;/code&gt; работает синхронно, в том же потоке, что и основной запрос. Если обработка ивента займет пару секунд, юзер будет сидеть и ждать ответа от сервера, хотя в базу данные уже записаны. Для решения данного казуса можно воспользоваться аннотацией &lt;code&gt;@Async&lt;/code&gt; над слушателем.&lt;/p&gt;

&lt;h2 dir="auto"&gt;Итого&lt;/h2&gt;

&lt;p dir="auto"&gt;Вместо того чтобы тащить отправку ивентов в конец верхних роутов, мы публикуем их локально. Spring берет на себя всю грязную работу по отслеживанию транзакций.&amp;nbsp;&lt;/p&gt;</summary>
    <dc:creator>Maxim Kalabukhov</dc:creator>
    <dc:date>2026-08-07T18:39:00Z</dc:date>
  </entry>
  <entry>
    <title>Этичный вайбкодинг: Как создавать AI-решения ответственно</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21289675" />
    <author>
      <name>Алексей Кондратьев</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21289675</id>
    <updated>2026-08-06T10:40:46Z</updated>
    <published>2026-08-06T10:27:00Z</published>
    <summary type="html">&lt;p&gt;Вайбкодинг (vibe coding) — это подход, при котором разработчик не пишет код построчно, а задаёт ИИ направление и общие параметры задачи на естественном языке, а модель генерирует решение . Это творческий, быстрый и демократичный способ создания ПО, где программист становится «дирижёром» . Однако эта свобода несёт и огромную ответственность.&lt;/p&gt;

&lt;p&gt;Кто отвечает за код, который вы не писали? За уязвимость, через которую украли данные пользователей? За дискриминационный алгоритм, который отказал человеку в услуге? В эпоху вайбкодинга эти вопросы перестают быть философскими. Они становятся вопросами профессиональной выживаемости.&lt;/p&gt;

&lt;h2&gt;Часть 1. Что такое «этичный вайбкодинг»?&lt;/h2&gt;

&lt;p&gt;Этичный вайбкодинг — это не просто «не нарушать закон». Это ответственное управление всем жизненным циклом AI-сгенерированного кода: от сбора данных для обучения моделей до развёртывания и сопровождения продукта .&lt;/p&gt;

&lt;p&gt;&lt;a href="https://ar5iv.labs.arxiv.org/html/2507.19743"&gt;Исследователи из Университета Конкордии ввели понятие Ethically Sourced Code Generation (ES-CodeGen)&lt;/a&gt; — 11 измерений, которые определяют этичность кода, сгенерированного ИИ :&lt;/p&gt;

&lt;p&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/21107385/Screenshot+from+2026-08-06+13-30-36.png/dd88b269-b18f-d970-774b-c5576fe870dd?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/21107385/Screenshot+from+2026-08-06+13-30-10.png/c0c733ee-b806-9c83-7c80-26068c6cf85a?imagePreview=1" /&gt;&lt;/p&gt;

&lt;h2&gt;Часть 2. Основные риски неэтичного вайбкодинга&lt;/h2&gt;

&lt;h4&gt;1. Безопасность: «Доверяй, но проверяй»&amp;nbsp;&lt;/h4&gt;

&lt;p&gt;Вайбкодер часто берёт код AI без проверки. Это открывает дорогу уязвимостям.&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;AI-галлюцинации и «slopsquatting»: Злоумышленники мониторят запросы к AI и создают вредоносные пакеты с названиями, которые AI генерирует как «наиболее вероятные». Вайбкодер скачивает такой пакет — и получает бэкдор в систему.&lt;/li&gt;
	&lt;li&gt;Устаревшие и опасные паттерны: AI генерирует то, что чаще всего встречалось в обучающих данных, а это часто — небезопасные практики&amp;nbsp;&lt;/li&gt;
&lt;/ul&gt;

&lt;h4&gt;2. Правовые риски: «AI скопировал чужой код, а платить — мне»&lt;/h4&gt;

&lt;p&gt;Исследования показывают, что 60% ответов AI-моделей содержат элементы плагиата . Если AI сгенерировал код, совпадающий с проприетарным, ответственность за нарушение лицензии ложится на вас .&lt;/p&gt;

&lt;h4&gt;3. Технический долг и потеря контроля&lt;/h4&gt;

&lt;p&gt;Когда код пишется быстро и без архитектурного планирования, накапливается «технический долг». Вайб-подход редко предполагает долгосрочное планирование, из-за чего системы сложно адаптировать под новые задачи. Через полгода такой код становится невозможно поддерживать.&lt;/p&gt;

&lt;h4&gt;4. Дезинформация и манипуляции&lt;/h4&gt;

&lt;p&gt;AI не предназначен для сообщения правды. Он генерирует вероятные утверждения на основе закономерностей в данных . Если вы используете AI для создания контента, вы рискуете распространять ложную информацию без злого умысла. Многие используют AI для генерации постов, статей, описаний. И забывают, что сгенерированный текст нужно маркировать как AI-контент. А когда этого не делают, возникает иллюзия, что текст написан человеком. Это дезинформация. Она может быть безобидной, когда речь идёт о рецепте запеканки, но смертельно опасной, когда — о медицинских рекомендациях или политических новостях.&amp;nbsp;&lt;/p&gt;

&lt;h4&gt;5. Профессиональная деградация&lt;/h4&gt;

&lt;p&gt;Постепенная утрата навыков ручного программирования и архитектурного мышления может привести к тому, что разработчики превращаются из архитекторов в операторов диалоговых интерфейсов, теряя контроль над критической инфраструктурой .&lt;/p&gt;

&lt;h2&gt;Часть 3. Как практиковать этичный вайбкодинг&lt;/h2&gt;

&lt;p&gt;Ответ простой. Вы не можете переложить ответственность на машину. Вы должны стать тем, кто держит руку на пульсе, потому что именно от вашего лица транслируется то, что вы создали. Безопасность и этичность – на ваших плечах, а &lt;strong&gt;незнание в этом случае не освобождает от ответственности.&lt;/strong&gt;&lt;br /&gt;
Что конкретно делать?&lt;/p&gt;

&lt;p&gt;Во-первых, &lt;strong&gt;научитесь разделять творчество и продукт&lt;/strong&gt;. Нейросети хороши для того чтобы развить идею, набросать черновик, понять, в каком направлении двигаться. Но когда речь идёт о коде, который будет работать с деньгами, медицинскими данными или критической инфраструктурой, здесь вайбкодинг — зона риска. Используйте его для вдохновения, но не для финального решения.&amp;nbsp;&lt;/p&gt;

&lt;p&gt;Вайбкодинг отлично подходит для:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Прототипирования и проверки гипотез .&lt;/li&gt;
	&lt;li&gt;Личных, pet-проектов.&lt;/li&gt;
	&lt;li&gt;Генерации «первого черновика» кода.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Не используйте вайбкодинг для:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Продуктов, работающих с чувствительными данными (финансы, медицина) .&lt;/li&gt;
	&lt;li&gt;Критической инфраструктуры.&lt;/li&gt;
	&lt;li&gt;Кода, который нельзя переписать с нуля в случае проблем.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Во-вторых, &lt;strong&gt;читайте код&lt;/strong&gt;. Да, это скучно. Да, AI написал его за вас. Но если вы не понимаете, что там происходит, вы не можете гарантировать его безопасность. Запускайте статические анализаторы, проверяйте лицензии всех библиотек, тестируйте граничные случаи. AI генерирует код, но только вы можете сказать: «Этот код правильный».&lt;/p&gt;

&lt;p&gt;В-третьих, требуйте от AI прозрачности. Спрашивайте, почему он выбрал именно это решение. Используйте технику цепочки рассуждений — когда AI не просто даёт ответ, а показывает ход мыслей. Это не только помогает вам понять логику, но и часто выявляет ошибки на раннем этапе. Если AI не может объяснить решение, возможно, это решение не стоит использовать.&lt;/p&gt;

&lt;p&gt;В-четвёртых, проектируйте ограничения заранее. Задавайте AI жёсткие рамки: «только компоненты из нашей дизайн-системы», «без внешних зависимостей», «с поддержкой доступности (WCAG)» . Это снижает риск «креативных», но опасных решений.&lt;/p&gt;

&lt;p&gt;И наконец, создавайте культуру ответственности в команде. Введите код-ревью для AI-сгенерированного кода. Разработайте политику использования AI-инструментов. И главное — признайте, что сгенерированный AI код — это ваша работа, и вы за неё отвечаете. Не говорите «это написал ChatGPT». Говорите «это сделал я с помощью ChatGPT». Разница колоссальная.&lt;/p&gt;

&lt;h2&gt;Часть 4. Дорога вперёд: от регулирования к осознанности&lt;/h2&gt;

&lt;p&gt;Этичный вайбкодинг требует не только технических изменений, но и культурных. Образование должно сместиться от «научить писать код» к «научить понимать код, управлять AI-инструментами и оценивать их результат». Иначе мы рискуем вырастить поколение операторов чат-ботов, которые не способны критически мыслить.&lt;/p&gt;

&lt;p&gt;Уже сейчас обсуждаются стандарты вроде AI Bills of Material — документирование всех компонентов AI-системы для обеспечения прозрачности. Почти 90% пользователей интернета выступают за регулирование генеративного AI. Вопрос не в том, будет ли регулирование, а в том, насколько разумным оно будет. Слишком жёсткое — задушит инновации. Слишком мягкое — приведёт к катастрофам.&lt;/p&gt;

&lt;h2&gt;Главное: творчество не отменяет ответственности&lt;/h2&gt;

&lt;p&gt;Вайбкодинг — это не «лёгкий путь» и не «читерство». Это новый способ создания, который требует от разработчика &lt;strong&gt;ещё большего профессионализма&lt;/strong&gt;, чем раньше. Потому что теперь вы отвечаете не только за свой код, но и за код, который сгенерировал AI.&lt;/p&gt;

&lt;p&gt;Адекватный вайбкодер не просто пишет промптики. Он проектирует архитектуру и задаёт ограничения. Он проверяет и тестирует каждое решение. Он понимает правовые и этические последствия. И — самое главное — он несёт ответственность за финальный продукт&lt;/p&gt;

&lt;p&gt;AI может написать код. Но только человек может сказать: «Этот код правильный, безопасный и этичный». И это — ваша работа. Это и есть этичный вайбкодинг.&lt;br /&gt;
&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;</summary>
    <dc:creator>Алексей Кондратьев</dc:creator>
    <dc:date>2026-08-06T10:27:00Z</dc:date>
  </entry>
  <entry>
    <title>Краткий обзор NiFi 2.x - 5 важнейших (для меня) изменений</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21288875" />
    <author>
      <name>Никита Рогаленко</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21288875</id>
    <updated>2026-08-04T14:23:28Z</updated>
    <published>2026-08-04T14:23:00Z</published>
    <summary type="html">&lt;p style="text-align: justify;"&gt;В моем блоге уже было множество заметок на тему преобразования и передачи данных с использованием Apache NiFi, однако все наши предыдущие проекты разрабатывались на разных&amp;nbsp;подверсиях&amp;nbsp;NiFi 1.0. И вот, спустя несколько лет после официального выхода,&amp;nbsp; NiFi 2.0 наконец добрался и до нас, в связи с чем возникла потребность кратко описать самые существенные (с точки зрения моего&amp;nbsp;личного&amp;nbsp;опыта&amp;nbsp;и специфики наших проектов)&amp;nbsp;нововведения в обновленном и переработанном NiFi.&lt;/p&gt;

&lt;h3 style="text-align: justify;"&gt;1. NiFi Registry устарел, появилась удобная интеграция с Git&lt;/h3&gt;

&lt;p style="text-align: justify;"&gt;Раньше для версионирования потоков и совместной работы нужно было поднимать NiFi Registry как отдельный сервис, в котором хранятся JSON'ы наших потоков данных. В NiFi 2.0 управление версиями встроено прямо «из коробки» через Registry Clients. Теперь появилась возможность&amp;nbsp;напрямую подключить свои Process Groups к GitHub, GitLab или Bitbucket. Компонент&amp;nbsp;GitFlowRegistryClient был и раньше, но его настройка была сложна, а взаимодействие с репозиторием все равно проксировалось через Registry. Теперь все будет делаться напрямую и с меньшим количеством лишних действий.&lt;/p&gt;

&lt;h3 style="text-align: justify;"&gt;2. Упростилась настройка SSL контекста&lt;/h3&gt;

&lt;p style="text-align: justify;"&gt;Настройка TLS/SSL в NiFi 1.x с использованием Java Keystore (JKS) и Truststore требовала множество&amp;nbsp;лишних действий и сложных конвертаций с использованием keytool. Теперь же появился&amp;nbsp;Controller Service под названием&amp;nbsp;PEMEncodedSSLContextProvider, представляющий собой новую версию&amp;nbsp;интерфейса SSLContextProvider специально для прямой работы с PEM-файлами. Он позволяет сразу же использовать тот набор файлов, который вам с наибольшей вероятностью пришлет системный администратор (.pem, .crt, .key) без необходимости создавать .jks файлы.&lt;/p&gt;

&lt;h3 style="text-align: justify;"&gt;3. Добавили параметризацию Controller Services&lt;/h3&gt;

&lt;p style="text-align: justify;"&gt;В версиях 1.x существовало жесткое архитектурное ограничение:&amp;nbsp;в настройках процессора (например, в поле Database Connection Pool для ExecuteSQL)&amp;nbsp;приходилось жестко выбирать конкретный сервис из выпадающего списка кликом мыши. В Apache NiFi 2.x разработчики&amp;nbsp;реализовали принцип «Parameterize All The Things», добавив возможность передавать Controller Services через параметры. Теперь в свойство процессора можно напрямую вписать текстовый параметр вида &lt;code&gt;#{database_service_id}&lt;/code&gt;. Это&amp;nbsp;изменение избавляет от необходимости вручную менять множество процессоров при миграции потоков между контурами. Теперь достаточно в один клик изменить значение самого параметра на ID нужного контроллера в Parameter Context, и NiFi автоматически остановит зависимые компоненты, подменит реализацию сервиса&amp;nbsp;и запустит пайплайн обратно.&lt;/p&gt;

&lt;h3 style="text-align: justify;"&gt;4. Новый встроенный Stateless-движок&lt;/h3&gt;

&lt;p style="text-align: justify;"&gt;С NiFi 2.x&amp;nbsp;экспериментальный&amp;nbsp;движок&amp;nbsp;Stateless превратился в полноценный встроенный режим работы групп процессов. Если обычно NiFi протоколирует и сохраняет в свой репозиторий практически любые действия, то теперь переключателем в UI можно&amp;nbsp;перевести выбранный поток данных в режим обработки&amp;nbsp;строго в оперативной памяти, полностью исключив ресурсоемкую запись файлов потока на жесткий диск. Кроме колоссального прироста производительности и ультра-низкой задержки на потоках из тысяч мелких сообщений, Stateless-режим гарантирует строгую транзакционность.&amp;nbsp;При сбое NiFi автоматически откатит всю цепочку шагов назад. Это может быть особенно полезно&amp;nbsp;для контейнерных сред и Kubernetes (поддержка которого также расширена в NiFi 2.0), позволяя&amp;nbsp;создавать легковесные&amp;nbsp;поды в кластере, которым&amp;nbsp;не нужны&amp;nbsp;дисковые хранилища. Раньше возможность stateless-запуска была неудобной, так как требовала использование отдельной CLI-утилиты.&lt;/p&gt;

&lt;h3 style="text-align: justify;"&gt;5. Появилась поддержка процессоров на Python&lt;/h3&gt;

&lt;p style="text-align: justify;"&gt;И одно из самых интересных. Множество статей в этом блоге было написано на тему того, как писать на Groovy сложные скрипты для конвертации данных. Теперь же при желании можно использовать полноценный Python. Если старый процессор ExecuteScript опирался на движок Jython (Python внутри JVM), в котором недоступны многие современные библиотеки, то в&amp;nbsp;NiFi 2.x интеграцию с Python переписали с нуля, сделав его языком первого класса (First-Class Support). Благодаря нативной поддержке полноценного CPython, разработчики теперь могут писать кастомные процессоры на чистом Python и бесшовно подключать к потокам данных. NiFi берет на себя всю рутину по управлению инфраструктурой - платформа сама изолирует процессы, автоматически создает виртуальные окружения (venv) для каждого процессора и скачивает нужные зависимости. То есть теперь необязательно&amp;nbsp;добавлять процессор ExecuteScript, внутри которого пишется код, а можно написать собственный Python-скрипт и положить его в специальную папку на сервере NiFi (обычно python/extensions). После перезапуска NiFi&amp;nbsp;скрипт превращается в настоящий процессор в общем списке. Groovy, таким образом, можно оставить только для более простых и быстрых трансформаций. Подробнее см.&amp;nbsp;&lt;a href="https://nifi.apache.org/nifi-docs/python-developer-guide.html#processor_api"&gt;NiFi Python Developer’s Guide&lt;/a&gt;&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;Вот пример процессора, который принимает входящий FlowFile, парсит JSON и добавляет новое поле с помощью&amp;nbsp;библиотеки numpy (NiFi сам скачает&amp;nbsp;через pip, если указать&amp;nbsp;в зависимостях):&lt;/p&gt;

&lt;pre class="brush:python;"&gt;
import json
import numpy as np
from nifiapi.flowfiletransform import FlowFileTransform, FlowFileTransformResult

class CalculateStats(FlowFileTransform):
    class Java:
        implements = ['org.apache.nifi.python.processor.FlowFileTransform']

    class ProcessorDetails:
        version = '2.0.0'
        description = 'Пример процессора NiFi 2.0'
        # Указываем внешние библиотеки, NiFi установит их автоматически через pip
        dependencies = ['numpy==1.26.4'] 

    def __init__(self, **kwargs):
        pass

    def transform(self, context, flowFile):
        content = flowFile.read().decode('utf-8')
        
        try:
            data = json.loads(content)
        except Exception:
            return FlowFileTransformResult(relationship="failure")

        data['generated_id'] = int(np.random.randint(1, 9))
        
        output_content = json.dumps(data)

        # Возвращаем обновленный контент в связь success
        return FlowFileTransformResult(
            relationship="success",
            contents=output_content.encode('utf-8')
        )
&lt;/pre&gt;

&lt;p style="text-align: justify;"&gt;&amp;nbsp;&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;Итак, сегодня мы рассмотрели наиболее значительные (на мой взгляд)&amp;nbsp;нововведения&amp;nbsp;NiFi 2.0 с точки зрения удобства и возможностей разработки. Кроме них существует еще множество изменений, среди которых более приятный визуал веб-интерфейса, различные оптимизации, добавление новых процессоров и удаление устаревших, и многое другое. Например, отдельно стоит выделить переход на более производительную Java 21 и отказ от поддержки устаревших версий систем (например, kafka 2.0). Таких внешне менее заметных изменений еще много, и для&amp;nbsp;каждого конкретного случая найдется свой процессор, контроллер сервисов и стратегии построения потоков&amp;nbsp;данных. Обо всем этом&amp;nbsp;мы еще поговорим в будущем.&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;&amp;nbsp;&lt;/p&gt;</summary>
    <dc:creator>Никита Рогаленко</dc:creator>
    <dc:date>2026-08-04T14:23:00Z</dc:date>
  </entry>
  <entry>
    <title>ChatGPT, Claude и Gemini в 2026 году: сравнение ИИ-помощников для разработчиков</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21287848" />
    <author>
      <name>Romo Fedoroff</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21287848</id>
    <updated>2026-08-01T18:24:42Z</updated>
    <published>2026-08-01T17:39:00Z</published>
    <summary type="html">&lt;style type="text/css"&gt;article p {
font-size:11pt;
font-family:Verdana, sans-serif;
text-align:justify;
color:#6a6a6a;
}

article img {
width: 90%;
}

article li {
 font-size:11pt;   
}

.centered {
text-align:center;
}


article .portlet-msg-info {
color: #232323;
background-color: #f9f9f9;
border-style: dashed;
border-color: #232323;
}
&lt;/style&gt;
&lt;h2&gt;Введение&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;За последние пару лет использование нейросетей в разработке перестало быть чем-то необычным - это часть повседневной работы. С их помощью пишут код, разбираются в чужих багах, готовят техническую документацию и обсуждают архитектурные решения ещё до того, как открыть IDE. Ни один серьёзный разговор о продуктивности разработчика в 2026 году уже не обходится без вопроса «а какой моделью ты пользуешься».&lt;/p&gt;

&lt;p&gt;К этому году на первый план вышли три инструмента: ChatGPT от OpenAI, Claude от Anthropic и Gemini от Google. У каждого - свой характер, своя философия и свои сильные стороны, и универсального победителя тут, забегая вперёд, не будет. Выбор скорее похож на выбор инструмента из ящика - гаечный ключ не заменяет отвёртку, даже если оба сделаны качественно. &lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Ниже - подробный разбор сильных и слабых сторон каждой модели и практических ориентиров, которые помогут понять, в каких сценариях разработки уместнее использовать ту или иную из них.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Сравнение по ключевым параметрам&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;table style="border-collapse: collapse; width: 100%;"&gt;
	&lt;thead&gt;
		&lt;tr style="border-bottom: 2px solid #ccc;"&gt;
			&lt;th style="padding: 8px; text-align: left;"&gt;Критерий&lt;/th&gt;
			&lt;th style="padding: 8px; text-align: left;"&gt;ChatGPT&lt;/th&gt;
			&lt;th style="padding: 8px; text-align: left;"&gt;Claude&lt;/th&gt;
			&lt;th style="padding: 8px; text-align: left;"&gt;Gemini&lt;/th&gt;
		&lt;/tr&gt;
	&lt;/thead&gt;
	&lt;tbody&gt;
		&lt;tr style="border-bottom: 1px solid #ddd;"&gt;
			&lt;td style="padding: 8px;"&gt;Сложная логика&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Хорошо&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Высокий уровень&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Хорошо&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr style="border-bottom: 1px solid #ddd;"&gt;
			&lt;td style="padding: 8px;"&gt;Отладка&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Хорошо&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Высокий уровень&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Хорошо&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr style="border-bottom: 1px solid #ddd;"&gt;
			&lt;td style="padding: 8px;"&gt;Скорость выдачи решений&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Высокий уровень&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Хорошо&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Хорошо&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr style="border-bottom: 1px solid #ddd;"&gt;
			&lt;td style="padding: 8px;"&gt;Качество кода&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Хорошо&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Высокий уровень&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Хорошо&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr style="border-bottom: 1px solid #ddd;"&gt;
			&lt;td style="padding: 8px;"&gt;Размер контекста&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;32K токенов&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;200K токенов&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;1M токенов&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr style="border-bottom: 1px solid #ddd;"&gt;
			&lt;td style="padding: 8px;"&gt;Объяснение кода&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Высокий уровень&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Высокий уровень&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Хорошо&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr style="border-bottom: 1px solid #ddd;"&gt;
			&lt;td style="padding: 8px;"&gt;Работа с изображениями и файлами&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Хорошо&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Хорошо&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Высокий уровень&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr style="border-bottom: 1px solid #ddd;"&gt;
			&lt;td style="padding: 8px;"&gt;Интеграция с внешними сервисами&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Хорошо&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Хорошо&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Высокий уровень&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr style="border-bottom: 1px solid #ddd;"&gt;
			&lt;td style="padding: 8px;"&gt;Скорость работы&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Средняя&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Средняя&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Высокая&lt;/td&gt;
		&lt;/tr&gt;
		&lt;tr&gt;
			&lt;td style="padding: 8px;"&gt;Стоимость&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;20$/мес.&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;17-20$/мес.&lt;/td&gt;
			&lt;td style="padding: 8px;"&gt;Бесплатно и 20$/мес.&lt;/td&gt;
		&lt;/tr&gt;
	&lt;/tbody&gt;
&lt;/table&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Цифры в таблице - это, конечно, упрощение: ни одна модель не сводится к набору баллов по шкале «плохо-хорошо». Но как отправная точка для дальнейшего разговора такая таблица вполне рабочая.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;ChatGPT: на все случаи жизни&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;ChatGPT остаётся, пожалуй, самым разносторонним инструментом из тройки. Модель одинаково уверенно чувствует себя в десятках языков и фреймворков, что неудивительно - за ней стоит один из самых больших массивов обучающих данных на рынке. Если нужно быстро получить рабочий вариант кода, ChatGPT почти всегда справляется без лишних вопросов и долгих раздумий.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Что в нём хорошо:&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Широкий охват технологий - от классических языков вроде Java и C++ до узкоспециализированных библиотек и совсем новых фреймворков фронтенда.&lt;/li&gt;
	&lt;li&gt;Быстрое прототипирование: типовые задачи решаются буквально с первого запроса, без необходимости уточнять формулировку.&lt;/li&gt;
	&lt;li&gt;Встроенный Code Interpreter - можно выполнить Python-код прямо в чате, построить график, обработать датасет или проверить гипотезу, не переключаясь между окнами и средами.&lt;/li&gt;
	&lt;li&gt;Возможность создавать собственные GPT под конкретные задачи команды - от ревью пул-реквестов до генерации тестовой документации по шаблону.&lt;/li&gt;
	&lt;li&gt;Экосистема плагинов и интеграций, упрощающая связку с внешними сервисами - от систем управления задачами до баз данных.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Слабые места:&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;На нестандартных алгоритмических задачах иногда проскальзывают логические неточности - код лучше перепроверять, особенно если он затрагивает граничные случаи или конкурентный доступ к данным.&lt;/li&gt;
	&lt;li&gt;Контекстное окно в 32K токенов заметно меньше, чем у конкурентов, и это ощущается при работе с крупными проектами: часть кода приходится подавать частями, теряя общую картину.&lt;/li&gt;
	&lt;li&gt;Знания о самых свежих версиях библиотек могут немного отставать от реальности, особенно если фреймворк выпустил breaking changes недавно.&lt;/li&gt;
	&lt;li&gt;При долгих диалогах модель иногда «забывает» ранние договорённости о стиле кода или структуре проекта.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Кому подходит: &lt;/strong&gt;тем, кто занимается разработкой общего профиля, быстро собирает прототипы или работает сразу с несколькими стеками технологий в течение дня.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Claude: вдумчивость и системность&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Anthropic делает ставку на глубину анализа, и это заметно буквально с первых секунд общения. Когда дело доходит до запутанных багов или проектирования архитектуры, Claude действует методично и редко торопится с выводами - модель скорее похожа на внимательного senior-разработчика, который сначала прочитает весь контекст, а потом уже начнёт писать код.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Сильные стороны:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Уверенно справляется со сложными алгоритмами, структурами данных и граничными случаями - часто разбирает задачу пошагово, прежде чем выдать итоговое решение, и проговаривает свои допущения вслух.&lt;/li&gt;
	&lt;li&gt;Хорошо находит нетипичные ошибки и умеет объяснить, откуда они взялись, а не просто предложить патч без объяснений - это особенно ценно при разборе чужого legacy-кода.&lt;/li&gt;
	&lt;li&gt;Пишет более аккуратный и идиоматичный код - с продуманными именами переменных, логичной структурой файлов и комментариями там, где они действительно нужны, а не «для галочки».&lt;/li&gt;
	&lt;li&gt;Контекст на 200K токенов позволяет держать в поле зрения сразу большой кусок кодовой базы - например, загрузить несколько связанных модулей и попросить модель проследить, как они взаимодействуют друг с другом.&lt;/li&gt;
	&lt;li&gt;Реже «додумывает» ответ там, где не уверена - вместо этого модель честно указывает на свою неуверенность и предлагает уточняющие вопросы, что снижает риск получить уверенно звучащую, но неверную рекомендацию.&lt;/li&gt;
	&lt;li&gt;Хорошо работает с рабочими артефактами: можно попросить модель собрать и отредактировать целый файл или небольшой проект, не разрывая диалог на десятки отдельных фрагментов кода.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Ограничения:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;На сложных запросах скорость ответа бывает ниже, чем у соседей по рынку - модель как будто действительно «думает», прежде чем ответить.&lt;/li&gt;
	&lt;li&gt;О совсем свежих фреймворках знания иногда требуют уточнения, особенно если библиотека вышла в последние месяцы.&lt;/li&gt;
	&lt;li&gt;Порой добавляет больше пояснений или проверок безопасности, чем требуется для короткой задачи, и в таких случаях приходится явно просить более краткий ответ.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Кому подходит:&lt;/strong&gt; для сложной отладки, код-ревью, архитектурных решений и вообще любых задач, где точность важнее скорости получения первого варианта.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Gemini: скорость и колоссальный контекст&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Флагман Google выигрывает там, где важны скорость и объём. Контекстное окно на миллион токенов - рекорд среди трёх моделей, а глубокая интеграция с экосистемой Google делает Gemini естественным выбором для соответствующих проектов и команд, уже завязанных на облако Google.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Плюсы:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Заметно быстрее генерирует ответы, чем ChatGPT и Claude, что особенно чувствуется при частых коротких запросах в течение рабочего дня.&lt;/li&gt;
	&lt;li&gt;Контекст в 1M токенов позволяет загружать целые репозитории и объёмную документацию за один раз - можно, например, скормить модели весь монорепозиторий среднего размера и попросить найти все места, где используется устаревший API.&lt;/li&gt;
	&lt;li&gt;Плотная интеграция с Firebase, Google Cloud Platform и разработкой под Android - от генерации конфигураций до отладки облачных функций.&lt;/li&gt;
	&lt;li&gt;Сильные мультимодальные возможности: модель уверенно работает со скриншотами интерфейсов, диаграммами архитектуры и даже видео, что удобно при разборе багов, которые проще показать, чем описать словами.&lt;/li&gt;
	&lt;li&gt;Есть функциональный бесплатный тариф, а для более требовательных задач - платный Gemini Pro.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Минусы:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Ответы на похожие запросы не всегда одинаковы по качеству - иногда одна и та же формулировка вопроса, заданная дважды, даёт заметно разные по глубине ответы.&lt;/li&gt;
	&lt;li&gt;Сгенерированный код рабочий, но нередко просит рефакторинга - стиль и структура не всегда соответствуют тому, что принято в конкретном проекте.&lt;/li&gt;
	&lt;li&gt;В глубокой логике заметно уступает Claude - на задачах с большим числом взаимосвязанных условий модель иногда упускает часть кейсов.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Кому подходит&lt;/strong&gt;: командам, завязанным на экосистему Google, работе с большими объёмами исходного кода и задачам, где скорость важнее идеальной чистоты первого варианта.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Стоимость и что за неё дают&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Формально ChatGPT Plus и Claude Pro стоят плюс-минус одинаково, и на первый взгляд выбор упирается только в качество ответов. Но на практике разница ощущается в лимитах: у ChatGPT более щедрые квоты на использование Code Interpreter и продвинутых моделей в течение дня, а у Claude - больший контекст, который в переводе на практическую пользу означает, что можно реже упираться в ограничение и чаще получать содержательный анализ большого куска кода за один запрос.&lt;/p&gt;

&lt;p&gt;Gemini здесь выделяется тем, что предлагает действительно рабочий бесплатный уровень - не урезанную демоверсию, а полноценный инструмент, которого хватает для большинства повседневных задач. Платный Gemini Pro добавляет доступ к более мощной модели и увеличенным лимитам, что имеет смысл в первую очередь для тех, кто уже работает в экосистеме Google Workspace и хочет получить нейросеть прямо в Docs, Sheets или Gmail без переключения контекста.&lt;/p&gt;

&lt;p&gt;Отдельная история - использование через API, где тарификация идёт за токены, а не по подписке. Здесь расклад может сильно отличаться от потребительских версий: для одних задач выгоднее окажется Claude из-за качества с первой попытки и меньшего числа повторных запросов, для других - Gemini из-за низкой цены на обработку больших объёмов текста.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Практическая проверка: рефакторинг медленного запроса с N+1-проблемой&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Чтобы сравнить модели не только на словах, каждой была дана одна и та же реальная по духу задача: есть обработчик заказов на Python (Django), который выводит список заказов вместе с данными о клиенте и товарах внутри каждого заказа. Страница подгружается медленно, а в логах видно классическую N+1-проблему - на каждый заказ уходит отдельный запрос к базе данных. Модели нужно было найти причину, объяснить её и предложить исправленную версию кода.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;ChatGPT&lt;/strong&gt; довольно быстро определил проблему и предложил использовать &lt;em&gt;select_related&lt;/em&gt;&amp;nbsp;и &lt;em&gt;prefetch_related&amp;nbsp;&lt;/em&gt;для нужных полей. Решение рабочее и действительно устраняет лишние запросы, но модель не стала проверять, как это скажется на сериализации связанных объектов, и в комментарии не упомянула, что для полей с большим количеством связанных записей &lt;em&gt;prefetch_related&lt;/em&gt;&amp;nbsp;стоит комбинировать с &lt;em&gt;Prefetch&lt;/em&gt;&amp;nbsp;и явной фильтрацией - это пришлось уточнять дополнительным вопросом.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Claude&lt;/strong&gt;&amp;nbsp;сначала попросил показать модель данных (или прямо уточнил структуру связей), после чего разложил проблему по шагам: показал, где именно возникает лишний запрос к базе, объяснил разницу между &lt;em&gt;select_related&amp;nbsp;&lt;/em&gt;для связей «один к одному» и &lt;em&gt;prefetch_related&lt;/em&gt;&amp;nbsp;для связей «один ко многим», и только затем предложил итоговый код с использованием &lt;em&gt;Prefetch&lt;/em&gt;&amp;nbsp;и аннотаций через &lt;em&gt;annotate&lt;/em&gt;, чтобы заодно избавиться от лишних вычислений на уровне Python. Решение сопровождалось короткими комментариями о том, почему выбран именно такой подход, и предупреждением о том, как изменение повлияет на существующие тесты.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Gemini&amp;nbsp;&lt;/strong&gt;справился быстрее всех и предложил похожее решение с &lt;em&gt;select_related&lt;/em&gt;/&lt;em&gt;prefetch_related&lt;/em&gt;, но в первом варианте не учёл, что часть полей уже подгружается через сериализатор с собственной логикой, из-за чего оптимизация частично дублировала запросы. После уточняющего вопроса модель быстро скорректировала ответ.&lt;/p&gt;

&lt;p&gt;Победитель в этом тесте - &lt;strong&gt;Claude&lt;/strong&gt;, но с оговоркой: разница проявилась не в том, «заработает ли код», а в глубине понимания последствий изменения и во внимании к деталям, которые легко упустить при беглом ревью. Для задачи, где нужен рабочий вариант здесь и сейчас, разница между тремя моделями была бы куда менее заметна.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Как выбрать инструмент под задачу&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;ChatGPT&lt;/strong&gt; стоит выбрать, если:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;нужен быстрый рабочий вариант под типовую задачу и нет времени на долгие уточнения;&lt;/li&gt;
	&lt;li&gt;вы изучаете незнакомый фреймворк или технологию и хотите получить широкий обзор возможных подходов;&lt;/li&gt;
	&lt;li&gt;важен сбалансированный код с пояснениями по ходу работы;&lt;/li&gt;
	&lt;li&gt;проект затрагивает сразу несколько языков программирования в течение одного дня;&lt;/li&gt;
	&lt;li&gt;нужно быстро прогнать расчёты или обработать данные через встроенный интерпретатор кода.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Claude&lt;/strong&gt; подойдёт, если:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;нужно найти и исправить сложный или «плавающий» баг, который другие инструменты уже не смогли объяснить;&lt;/li&gt;
	&lt;li&gt;качество, чистота и предсказуемость кода важнее скорости получения первого варианта;&lt;/li&gt;
	&lt;li&gt;предстоит разобрать крупный модуль или весь проект целиком, держа в голове множество взаимосвязей;&lt;/li&gt;
	&lt;li&gt;принимаются архитектурные решения или проводится код-ревью, где важна аргументация, а не только итоговый код;&lt;/li&gt;
	&lt;li&gt;команда ценит, когда модель честно говорит «не уверен» вместо того, чтобы правдоподобно ошибаться.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Gemini&lt;/strong&gt; имеет смысл использовать, если:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;критична скорость ответа, а объём диалога в течение дня большой;&lt;/li&gt;
	&lt;li&gt;проект завязан на Google Cloud, Firebase или Android;&lt;/li&gt;
	&lt;li&gt;нужно передать модели большой объём кода, документации или даже видео и скриншотов;&lt;/li&gt;
	&lt;li&gt;важен бесплатный, но при этом достаточно сильный инструмент без необходимости сразу оформлять подписку.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Что касается вопроса, какой инструмент вообще «лучше» - тут, честно говоря, нет однозначного ответа, и это не попытка уклониться от прямой оценки. Практика показывает, что для сложной логики и отладки увереннее ведёт себя Claude: он реже допускает логические ошибки и лучше объясняет ход рассуждений. ChatGPT при этом остаётся самым универсальным решением на каждый день - если задача типовая, а времени мало, он почти всегда выдаёт рабочий вариант с первой попытки и охватывает при этом более широкий круг технологий. Gemini, в свою очередь, не столько соперничает с двумя другими моделями в глубине логики, сколько предлагает другой набор преимуществ - скорость и контекст, которых физически не хватает конкурентам, особенно при работе с большими кодовыми базами или проектами в экосистеме Google.&lt;/p&gt;

&lt;p&gt;Отдельно стоит сказать про написание кода как таковое. Если сравнивать именно чистоту и структуру итогового результата, а не только его работоспособность, Claude обычно выигрывает: переменные называются осмысленно, комментарии появляются там, где они правда нужны, а сама архитектура решения ближе к тому, что можно сразу отправить на код-ревью без правок. Код от ChatGPT и Gemini при этом тоже вполне рабочий и решает поставленную задачу - но чаще нуждается в стилистической доработке перед тем, как попасть в основную ветку проекта. Для команд, где на счету каждая минута ревью, это может оказаться решающим фактором.&lt;/p&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;h2&gt;Вместо заключения&lt;/h2&gt;

&lt;p&gt;&lt;meta charset="UTF-8" /&gt;&lt;/p&gt;

&lt;p&gt;Если собрать всё сказанное воедино, получается следующая картина.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Во-первых, единого лидера среди трёх моделей нет - выбор всегда зависит от контекста: отладка, проектирование, быстрый прототип или работа с объёмной кодовой базой требуют разных сильных сторон, и ни один инструмент не закрывает все сценарии одинаково хорошо.&lt;/p&gt;

&lt;p&gt;Во-вторых, Claude - это выбор в пользу качества и предсказуемости. Он реже пропускает скрытые баги, пишет строго типизированный и аккуратный код и лучше других справляется с архитектурными задачами, где цена ошибки высока.&lt;/p&gt;

&lt;p&gt;В-третьих, ChatGPT остаётся самым универсальным вариантом - для повседневной разработки, быстрых проверок гипотез и знакомства с новыми технологиями он подходит лучше всего именно за счёт скорости и широты охвата.&lt;/p&gt;

&lt;p&gt;В-четвёртых, Gemini берёт скоростью и объёмом контекста - миллион токенов делает его по-настоящему удобным инструментом для анализа целых репозиториев и работы в стеке Google, а щедрый бесплатный тариф снижает порог входа.&lt;/p&gt;

&lt;p&gt;И наконец, на практике лучший результат чаще всего даёт не выбор одного-единственного инструмента на все случаи жизни, а осознанная комбинация всех трёх под конкретные этапы работы: быстрый прототип на ChatGPT, вдумчивое ревью и отладку на Claude, анализ большого объёма кода и работу с Google-сервисами на Gemini. Такой подход требует немного больше организационной дисциплины, зато позволяет использовать сильные стороны каждой модели именно там, где они действительно раскрываются.&lt;/p&gt;
&lt;/blockquote&gt;</summary>
    <dc:creator>Romo Fedoroff</dc:creator>
    <dc:date>2026-08-01T17:39:00Z</dc:date>
  </entry>
  <entry>
    <title>Java и деньги</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21278698" />
    <author>
      <name>Maxim Kalabukhov</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21278698</id>
    <updated>2026-07-09T16:13:11Z</updated>
    <published>2026-07-09T16:10:00Z</published>
    <summary type="html">&lt;p&gt;&lt;!-- obsidian --&gt;&lt;/p&gt;

&lt;p&gt;Главная проблема работа с деньгами в программировании заключается в том, что привычные нам десятичные дроби компьютер хранит в двоичной системе. Из-за этого &lt;code&gt;0.1 + 0.2&lt;/code&gt; в &lt;code&gt;double&lt;/code&gt; превращается в &lt;code&gt;0.30000000000000004&lt;/code&gt;. В финансовой сфере такая погрешность недопустима.&lt;/p&gt;

&lt;p&gt;В Java есть три основных способа обойти эту проблему. Разберем их:&lt;/p&gt;

&lt;ol&gt;
	&lt;li&gt;Два &lt;code&gt;long&lt;/code&gt;: рубли и копейки отдельно&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Первое, что приходит в голову - разделить сумму на две части и хранить рубли и копейки в разных переменных типа &lt;code&gt;long&lt;/code&gt;.&lt;/p&gt;

&lt;pre&gt;
&lt;code&gt;long rubles = 100;
long kopecks = 50;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;&lt;strong&gt;Плюсы:&lt;/strong&gt; Максимальная точность, никаких проблем с двоичным представлением.&lt;br /&gt;
&lt;strong&gt;Минусы:&lt;/strong&gt; Любая математическая операция превращается в сложный код. Вам нужно вручную переносить разряды при сложении копеек, учитывать знаки при отрицательных суммах и т.д. В общем ад для разработчика.&lt;/p&gt;

&lt;ol start="2"&gt;
	&lt;li&gt;Один &lt;code&gt;long&lt;/code&gt;: всё в копейках&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Более прагматичный подход. Мы отказываемся от дробей и храним всю сумму в минорных единицах (в копейках, центах и т.д.).&lt;/p&gt;

&lt;pre&gt;
&lt;code&gt;long totalKopecks = 10050; // 100 рублей 50 копеек
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;&lt;strong&gt;Плюсы:&lt;/strong&gt; Скорость работы примитивов, нет проблем с округлением при сложении и вычитании.&lt;br /&gt;
&lt;strong&gt;Минусы:&lt;/strong&gt; Проблемы начинаются при умножении и делении. Например, при расчете налога 13% от 100.50 рублей вы получите &lt;code&gt;1306.5&lt;/code&gt; копеек. Придется вручную реализовывать логику округления. Помимо этого становиться сложно работать с валютами, где нет минорных единиц.&lt;/p&gt;

&lt;ol start="3"&gt;
	&lt;li&gt;&lt;code&gt;BigDecimal&lt;/code&gt;: золото&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Основная часть профессиональных финансовых систем на Java использует &lt;code&gt;java.math.BigDecimal&lt;/code&gt;. Этот класс представляет число в виде массива цифр произвольной длины и отдельной переменной для позиции запятой. Он лишен проблем двоичного округления.&lt;/p&gt;

&lt;p&gt;Имейте ввиду&amp;nbsp;- создавать &lt;code&gt;BigDecimal&lt;/code&gt; из &lt;code&gt;double&amp;nbsp;&lt;/code&gt;это ошибка:&lt;/p&gt;

&lt;pre&gt;
&lt;code&gt;// ТАК ДЕЛАТЬ НЕЛЬЗЯ
BigDecimal bad = new BigDecimal(0.1); // 0.1000000000000000055511151231257827021181583404541015625

// ТАК ПРАВИЛЬНО
BigDecimal good = new BigDecimal("0.1"); // Из строки
BigDecimal alsoGood = BigDecimal.valueOf(0.1); // Или через фабричный метод
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Главная сила &lt;code&gt;BigDecimal&lt;/code&gt; - строгий контроль над округлением. При делении всегда нужно указывать правило округления, иначе программа упадет с &lt;code&gt;ArithmeticException&lt;/code&gt;, если результат это бесконечная дробь.&lt;/p&gt;

&lt;pre&gt;
&lt;code&gt;BigDecimal total = new BigDecimal("100.00");
BigDecimal percent = new BigDecimal("0.13"); // 13%

// Делим нацело с округлением до копеек
// RoundingMode.HALF_EVEN — банковское округление
BigDecimal tax = total.multiply(percent)
                      .setScale(2, RoundingMode.HALF_EVEN);
&lt;/code&gt;&lt;/pre&gt;

&lt;h3 data-heading="Итог"&gt;Итог&lt;/h3&gt;

&lt;ul&gt;
	&lt;li&gt;&lt;strong&gt;&lt;code&gt;BigDecimal&lt;/code&gt;&lt;/strong&gt; - выбор для 99% бизнес-приложений, банковских систем. Он медленнее примитивов, но спасает от критических багов с округлением и потерей точности.&lt;/li&gt;
	&lt;li&gt;Хранение в минорных единицах - может подходить для того самого одно процента высоконагруженных систем, где важна каждая наносекунда.&lt;/li&gt;
	&lt;li&gt;Два &lt;code&gt;long&lt;/code&gt; - cложность поддержки перевешивает любые плюсы.&lt;/li&gt;
&lt;/ul&gt;</summary>
    <dc:creator>Maxim Kalabukhov</dc:creator>
    <dc:date>2026-07-09T16:10:00Z</dc:date>
  </entry>
  <entry>
    <title>Gstack: Как Гэрри Тан превращает вайб-кодинг в рабочий процесс</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21278583" />
    <author>
      <name>Vadim Mikhu</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21278583</id>
    <updated>2026-07-09T11:33:18Z</updated>
    <published>2026-07-09T10:25:00Z</published>
    <summary type="html">&lt;p data-sourcepos="3:1-3:406;66-471"&gt;Вайб-кодинг подкупает лёгкостью: описываешь словами, что нужно, и через минуту на экране рабочий прототип. Никаких тикетов, ревью и совещаний, поток идей сразу в код. Но у потока есть ограничения. Пока проект маленький, всё живёт; как только он вырастает, агент уверенно выдаёт код, который выглядит правильным, но таким не является, архитектура плывёт, баги всплывают в проде.&lt;/p&gt;

&lt;p data-sourcepos="3:1-3:406;66-471"&gt;В эту боль и целится gstack -&amp;nbsp;набор инструментов, который президент и CEO Y Combinator Гэрри Тан выложил в открытый доступ под лицензией MIT.&lt;/p&gt;

&lt;h2 data-sourcepos="7:1-7:11;843-853"&gt;Что это&lt;/h2&gt;

&lt;p&gt;&lt;img alt="gstack is not a dev tool. it's Garry Tan's brain on AI | by Luong NGUYEN |  Medium" src="https://miro.medium.com/0*XgShYxg9EqpOJTlQ" /&gt;&lt;/p&gt;

&lt;p data-sourcepos="9:1-9:704;855-1558"&gt;gstack это не приложение, а два с лишним десятка специализированных скиллов для Claude Code&amp;nbsp;и набор&amp;nbsp;инструментов. Значительную часть репозитория Тан написал в соавторстве с самим Claude. За пару недель репозиторий собрал десятки тысяч звёзд на GitHub. И это похоже на ожидаемый результат.&lt;/p&gt;

&lt;p data-sourcepos="11:1-11:296;1560-1855"&gt;Ставка тут почти еретическая для индустрии, привыкшей строить тулинг: правильный уровень абстракции для ИИ-разработки позволит копилоту стать настоящей командой, хоть и глупых, но полноценных разработчиков у вас под рукой. Выстраданные промпты, которые заставляют агента вести себя,&amp;nbsp;как дисциплинированная команда, больше похожи на должностные инструкции у реальных людей.&lt;/p&gt;

&lt;h2 data-sourcepos="13:1-13:38;1857-1894"&gt;Не умнее программисты, а лучше процесс&lt;/h2&gt;

&lt;p data-sourcepos="15:1-15:312;1896-2207"&gt;Идея простая. Разработчики одиночки проигрывают большим командам не из-за квалификации, они пропускают процесс распараллеливания задач&amp;nbsp;(очевидно, так как они одиночки). Кроме того, человек, вайбкодящий по вечерам очередной фитнес трекер, что-нибудь да соберёт, но у него нет ни осмысления задачи до старта, ни адекватной цели. А вся разница между рабочим продуктом и грудой техдолга живёт именно там.&lt;/p&gt;

&lt;p data-sourcepos="17:1-17:255;2209-2463"&gt;Gstack внедряет эти этапы в вайбкодинг&amp;nbsp;и превращает Claude Code из реактивного автодополнения в процесс с контрольными точками. Тан построил оргструктуру для выпуска софта и зашил в неё то, как сам оценивает продукты после тысяч стартапов, прошедших через YC.&lt;/p&gt;

&lt;p data-sourcepos="19:1-19:386;2465-2850"&gt;Один скилл играет CEO, который переосмысляет продукт. Другой — инженерного менеджера, фиксирующего архитектуру. Третий — дизайнера, отлавливающего генеративную серость, которую агент выдаёт по умолчанию. Четвёртый — параноидального ревьюера, что ищет баги до прода. Пятый — QA, который открывает настоящий браузер, кликает по приложению и заводит на вас баги.&lt;/p&gt;

&lt;h2 data-sourcepos="21:1-21:16;2852-2867"&gt;А что,&amp;nbsp;так&amp;nbsp;можно было&lt;/h2&gt;

&lt;p data-sourcepos="23:1-23:744;2869-3612"&gt;Отдельные умные промпты можно написать и без gstack. Отличают его хендоффы — передачи между этапами.&lt;/p&gt;

&lt;p data-sourcepos="23:1-23:744;2869-3612"&gt;&lt;code&gt;/office-hours&lt;/code&gt; не бросается кодить, а спорит с вашей формулировкой: сказали «приложение для утренней сводки» — получите ответ, что это персональный AI-начштаба, и вот пять возможностей, которые вы описали, сами того не заметив. Дальше&lt;/p&gt;

&lt;p data-sourcepos="23:1-23:744;2869-3612"&gt;&lt;code&gt;/plan-ceo-review&lt;/code&gt; ищет «десятизвёздочный продукт внутри запроса» в одном из четырёх режимов — от расширения замысла до сокращения. Проектный документ из &lt;code&gt;/office-hours&lt;/code&gt; читает инженерное ревью, пишет тест-план, а его подхватывает&amp;nbsp;&lt;code&gt;/qa&lt;/code&gt;.&lt;/p&gt;

&lt;p data-sourcepos="23:1-23:744;2869-3612"&gt;Эту цепочку случайным промптингом не воспроизвести. Последовательность&amp;nbsp;повторяет настоящий спринт: подумать, спланировать, собрать, проверить, протестировать, выкатить, отрефлексировать.&lt;/p&gt;

&lt;p data-sourcepos="23:1-23:744;2869-3612"&gt;Есть и защитные команды. &lt;code&gt;/careful&lt;/code&gt; предупреждает перед деструктивными командами, &lt;code&gt;/freeze&lt;/code&gt; запирает правки в одной директории, &lt;code&gt;/guard&lt;/code&gt; включает оба сразу, а &lt;code&gt;/investigate&lt;/code&gt; при отладке замораживает всё, кроме чинимого модуля, чтобы агент в запале не переписал полпроекта.&lt;/p&gt;

&lt;p data-sourcepos="23:1-23:744;2869-3612"&gt;&lt;code&gt;/codex&lt;/code&gt; зовёт независимое ревью от Codex CLI и показывает, где модели сходятся, а где спорят.&lt;/p&gt;

&lt;h2 data-sourcepos="27:1-27:13;4082-4094"&gt;Зачем это&lt;/h2&gt;

&lt;p data-sourcepos="29:1-29:288;4096-4383"&gt;Пайплайн и есть продукт, агент — рабочая сила. Проведя с ИИ-агентом достаточно времени, ты&amp;nbsp;перестаёшь видеть в нём гения-универсала, начинаешь управлять им как командой: каждой роли узкая задача и чистая передача дальше. Так всегда работали нормальные команды, просто теперь в терминале.&lt;/p&gt;

&lt;p data-sourcepos="31:1-31:287;4385-4671"&gt;Цифры Тан приводит бодрые: по его замерам он пишет примерно в восемьсот раз больше кода в день, чем в 2013-м, когда программировал сам. К таким метрикам стоит относиться со скепсисом, но порядок величины впечатляет.&lt;/p&gt;

&lt;h2 data-sourcepos="33:1-33:17;4673-4689"&gt;Кому подойдёт&lt;/h2&gt;

&lt;p data-sourcepos="35:1-35:240;4691-4930"&gt;gstack это всего лишь набор скиллов, и он ровно настолько точен, насколько конкретен ваш контекст: расплывчатое описание проекта даёт бесполезные роли.&lt;/p&gt;

&lt;p data-sourcepos="37:1-37:376;4932-5307"&gt;Лучше всего применение gstack ложится на основателя или инженера ранней стадии, которому надо закрывать продукт, инженерию и ресёрч. Хуже -&amp;nbsp;на большие команды с устоявшимся разделением ролей, где вся эта машинерия избыточна, и на тех, кто ждёт коробку без настройки: вложиться на старте придётся, и gstack рассчитывает, что свой продукт вы понимаете.&lt;/p&gt;</summary>
    <dc:creator>Vadim Mikhu</dc:creator>
    <dc:date>2026-07-09T10:25:00Z</dc:date>
  </entry>
  <entry>
    <title>Промпт-инжиниринг для дизайна и кода: Как разговаривать с AI, чтобы он делал работу, а не мусор</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21277811" />
    <author>
      <name>Алексей Кондратьев</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21277811</id>
    <updated>2026-07-07T15:20:47Z</updated>
    <published>2026-07-07T14:49:00Z</published>
    <summary type="html">&lt;p&gt;Вы когда-нибудь просили нейросеть нарисовать «современный интерфейс для интернет-магазина» и получали нечто, напоминающее сайт 2010 года с кислотными цветами и непонятными кнопками? Или просили сгенерировать компонент на React, а AI выдавал код, который невозможно поддерживать, полный устаревших практик и багов?&lt;/p&gt;

&lt;p&gt;Это не «глупая нейросеть». Это вы плохо объяснили задачу.&lt;/p&gt;

&lt;p&gt;Промпт-инжиниринг (prompt engineering) — это искусство формулировать запрос к AI так, чтобы на выходе получался качественный, пригодный к использованию результат. В эпоху, когда нейросети стали стандартным инструментом дизайнера и разработчика, умение писать хорошие промпты — это базовый профессиональный навык, не менее важный, чем знание Figma или React.&lt;/p&gt;

&lt;p&gt;Эта статья — практическое руководство по промпт-инжинирингу для дизайна и кода. Никакой магии. Только конкретные техники, примеры и принципы, которые работают прямо сейчас.&lt;/p&gt;

&lt;h2&gt;Часть 1. Почему промпт-инжиниринг — это новая суперсила&lt;/h2&gt;

&lt;p&gt;В 2026 году нейросети умеют очень многое. Midjourney и DALL-E 3 создают фотореалистичные изображения. Figma AI генерирует многостраничные прототипы по текстовому описанию. Lovable и v0 превращают промпт в работающее React-приложение за минуты.&lt;/p&gt;

&lt;p&gt;Но есть одна проблема: AI не читает ваши мысли.&lt;/p&gt;

&lt;p&gt;Он не знает ваш брендбук. Не понимает, что «современный» для вас — это минимализм с крупной типографикой, а не неоморфизм с кислотными градиентами. Не догадывается, что «быстрый компонент» означает без лишних зависимостей и с мемоизацией.&lt;/p&gt;

&lt;p&gt;Хороший промпт — это не «пожелание». Это техническое задание, написанное на языке, который AI понимает идеально.&lt;/p&gt;

&lt;p&gt;&lt;b id="docs-internal-guid-aad178b6-7fff-776d-34e6-2932fd3e08cb"&gt;Разница между плохим и хорошим промптом&lt;/b&gt;&lt;/p&gt;

&lt;p&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/21107385/Screenshot+from+2026-07-07+18-06-08.png/c58185f1-bf8b-83fa-2dd7-111afee2ad88?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p&gt;В первом случае AI гадает, что вы имели в виду. Во втором — у него есть чёткая инструкция, и он выдаёт предсказуемый, качественный результат.&lt;/p&gt;

&lt;p&gt;&lt;b id="docs-internal-guid-0808a896-7fff-4224-1ed2-4c7995b9de7d"&gt;Почему это особенно важно для дизайна и кода?&lt;/b&gt;&lt;/p&gt;

&lt;p&gt;Дизайн и код — это дисциплины с высокой ценой ошибки. Плохой дизайн убивает конверсию. Плохой код создаёт тонну технического долга. AI генерирует быстро, но он также быстро генерирует плохие решения, если вы не задали правильные ограничения.&lt;/p&gt;

&lt;h2&gt;Часть 2. Базовые принципы хорошего промпта&lt;/h2&gt;

&lt;p&gt;Прежде чем переходить к продвинутым техникам, давайте зафиксируем фундамент. Хороший промпт всегда содержит четыре компонента:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;1. Контекст (Context)&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;AI должен знать, для чего он это делает. Кто пользователь? В каком продукте будет использоваться результат? Какие ограничения накладывает среда?&lt;/p&gt;

&lt;p&gt;Плохо: «Нарисуй дашборд для аналитики»&lt;br /&gt;
Хорошо: «Создай дизайн дашборда для менеджеров интернет-магазина. Основные метрики: выручка за сегодня, конверсия, средний чек, количество заказов. Данные обновляются каждые 5 минут. Пользователи смотрят на дашборд на 24-дюймовых мониторах по 8 часов в день — информация должна быть плотной, без лишних отступов. Приоритет — быстрый поиск аномалий, не эстетика.»&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Роль (Role)&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Скажите AI, кем он должен себя представлять. Это один из самых эффективных приёмов.&lt;/p&gt;

&lt;p&gt;Пример для дизайна: «Ты — senior-дизайнер с 10-летним опытом в B2B-продуктах. Ты специализируешься на дашбордах и аналитических интерфейсах. Твои работы — лаконичные, функциональные, без лишнего визуального шума.»&lt;/p&gt;

&lt;p&gt;Пример для кода: «Ты — ведущий фронтенд-разработчик, фанатик производительности и доступности. Ты не используешь неоправданные зависимости, пишешь чистый TypeScript и всегда добавляешь атрибуты aria-* для скрин-ридеров.»&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Конкретные требования (Specifications)&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Чем детальнее — тем лучше. Цвета, шрифты, размеры, структура компонентов, поведение при ошибках, состояния загрузки.&lt;/p&gt;

&lt;p&gt;Приём «инвертирования»: скажите AI не только что делать, но и чего не делать.&lt;/p&gt;

&lt;p&gt;«Не используй синий цвет — он ассоциируется с конкурентом. Не делай анимацию длиннее 200 мс. Не добавляй карусели — исследования показывают, что их никто не листает. Не генерируй SVG-иконки, используй импорт из react-icons.»&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;4. Формат вывода (Output Format)&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Скажите AI, в каком виде вы хотите получить результат. JSON, HTML/CSS, React-компонент, описание дизайн-системы, список токенов.&lt;/p&gt;

&lt;p&gt;Пример: «Верни ответ в формате JSON с полями: "prompt" (использованный промпт), "reasoning" (почему выбрана такая структура), "code" (React-компонент), "designTokens" (цвета и шрифты в формате CSS-переменных).»&lt;/p&gt;

&lt;h2&gt;Часть 3. Продвинутые техники промпт-инжиниринга&lt;/h2&gt;

&lt;p&gt;Базовый уровень позволит вам получать «нормальные» результаты. Продвинутые техники — превращать AI в предсказуемого, профессионального ассистента.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3.1. Chain-of-Thought (CoT) — цепочка рассуждений&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Вместо того чтобы просить AI дать готовый ответ, попросите его показать ход мыслей. Это невероятно повышает качество результата, особенно для сложных задач.&lt;/p&gt;

&lt;p&gt;Пример для дизайна:&lt;/p&gt;

&lt;p&gt;«Сначала подумай и напиши свои рассуждения в тег &amp;lt;thinking&amp;gt;. Проанализируй задачу: кто пользователь, какова его главная цель, какие болевые точки. Затем предложи 3 разных подхода к организации информации. Потом выбери лучший и обоснуй выбор. И только после этого создавай финальный дизайн в Figma-совместимом формате.»&lt;/p&gt;

&lt;p&gt;Пример для кода:&lt;/p&gt;

&lt;p&gt;«Прежде чем писать код, напиши в комментариях:&lt;/p&gt;

&lt;ol&gt;
	&lt;li&gt;Какие состояния есть у этого компонента?&lt;/li&gt;
	&lt;li&gt;Какие побочные эффекты нужно учесть?&lt;/li&gt;
	&lt;li&gt;Какой подход к управлению состоянием выбран и почему?&lt;/li&gt;
	&lt;li&gt;Какие edge cases (пустые данные, ошибки, загрузка) обрабатываются? После этого — реализация.»&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;3.2. Few-shot examples — учим AI на примерах&lt;/p&gt;

&lt;p&gt;Самый мощный способ задать стиль, структуру или паттерн — показать пример. 1-3 примера достаточно, чтобы AI «схватил» нужный формат и тон.&lt;/p&gt;

&lt;p&gt;Пример для дизайна:&lt;/p&gt;

&lt;p&gt;Вот как я хочу, чтобы выглядела карточка товара. [Вставьте ссылку на Figma или скриншот]&lt;/p&gt;

&lt;p&gt;А вот как я не хочу: [вставьте контр-пример]&lt;/p&gt;

&lt;p&gt;Теперь создай карточку для категории "Спортивные товары", следуя тому же стилю.&lt;/p&gt;

&lt;p&gt;Пример для кода:&lt;/p&gt;

&lt;p&gt;Вот пример компонента, который я считаю эталонным по качеству:&lt;/p&gt;

&lt;pre class="brush:jscript;"&gt;
type ButtonVariantType =
  | "primary"
  | "destructive"
  | "secondary"
  | "blue-button"
  | "link"
  | "link-blue";

const VARIANT_COLOR_TEXT_MAP: Record&amp;lt;ButtonVariantType, ColorToken&amp;gt; = {
  primary: "white",
  destructive: "white",
  secondary: "black-800",
  link: "black-800",
  "blue-button": "white",
  "link-blue": "blue-1000",
};

const DISABLED_VARIANT_COLOR_TEXT_MAP: Partial&amp;lt;Record&amp;lt;ButtonVariantType, ColorToken&amp;gt;&amp;gt; = {
  secondary: "black-400",
};

const getSvgIconWithColor = (svgIcon: ReactNode, color: ColorToken) =&amp;gt; {
  if (!isValidElement&amp;lt;{ color?: ColorToken }&amp;gt;(svgIcon)) return svgIcon;

  return cloneElement(svgIcon, { color: svgIcon.props.color ?? color });
};

type SvgPositionType = "left" | "right";

type ButtonSizeType = "regular" | "small";
type ButtonRadiusType = "default" | "none";

export type ButtonProps = Props&amp;lt;
  {
    variant: ButtonVariantType;
    size?: ButtonSizeType;
    radius?: ButtonRadiusType;
    buttonJustify?: CSSProperties["justifyContent"];
    svgIcon?: ReactNode;
    svgPosition?: SvgPositionType;
    isLoading?: boolean;
    fitContent?: boolean;
  },
  true,
  ButtonHTMLAttributes&amp;lt;HTMLButtonElement&amp;gt;
&amp;gt;;

export const Button = componentWithRef&amp;lt;ButtonProps, HTMLButtonElement&amp;gt;(
  (
    {
      variant,
      svgIcon,
      svgPosition = "left",
      size = "regular",
      radius = "default",
      buttonJustify = "center",
      isLoading = false,
      fitContent = false,
      type = "button",
      disabled = false,
      children,
      className,
      style,
      ...rest
    },
    ref
  ) =&amp;gt; {
    const isDisabled = disabled || isLoading;
    const currentColor =
      (isDisabled &amp;amp;&amp;amp; DISABLED_VARIANT_COLOR_TEXT_MAP[variant]) ||
      VARIANT_COLOR_TEXT_MAP[variant];
    const svgIconWithColor = getSvgIconWithColor(svgIcon, currentColor);

    return (
      &amp;lt;button
        ref={ref}
        type={type}
        className={clsx(
          "pm-button",
          {
            [`button--${variant}`]: variant,
            [`button--${size}`]: size,
            [`button--radius-${radius}`]: radius,
            "button--fit-content": fitContent,
          },
          className
        )}
        style={{ ...style, justifyContent: buttonJustify }}
        disabled={isDisabled}
        {...rest}
      &amp;gt;
        {isLoading &amp;amp;&amp;amp; &amp;lt;Loader color={currentColor} /&amp;gt;}
        {svgPosition === "left" &amp;amp;&amp;amp; svgIconWithColor}
        &amp;lt;Text variant="text3" color={currentColor}&amp;gt;
          {children}
        &amp;lt;/Text&amp;gt;
        {svgPosition === "right" &amp;amp;&amp;amp; svgIconWithColor}
      &amp;lt;/button&amp;gt;
    );
  }
);
&lt;/pre&gt;

&lt;p&gt;Теперь создай похожий компонент для дропдауна с поиском. Используй те же паттерны: мемоизация, обработка клика вне компонента, TypeScript, JSDoc.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3.3. Ограничения (Constraints) — границы творчества&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;AI любит придумывать «креативные» решения, которые нарушают ваши требования. Задавайте жёсткие ограничения.&lt;/p&gt;

&lt;p&gt;Категории ограничений:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Контекст и среда: «Сайт будет работать в регионах с плохим интернетом. Все изображения должны быть оптимизированы, максимальный размер страницы — 500KB.»&lt;/li&gt;
	&lt;li&gt;Доступность: «Соответствие WCAG 2.2 уровня AA. Контраст текста 4.5:1, управление с клавиатуры, скрытие контента от скрин-ридеров там, где это нужно.»&lt;/li&gt;
	&lt;li&gt;Производительность: «Компонент не должен вызывать лишних ререндеров. Используй React.memo и useCallback. Анимации только через CSS transform и opacity — ничего, что вызывает reflow.»&lt;/li&gt;
	&lt;li&gt;Бренд: «Только фирменные цвета: #1E3A8A, #3B82F6, #F59E0B. Не используй красный — он триггерит негативные ассоциации. Типографика — только Inter.»&lt;/li&gt;
	&lt;li&gt;Технические ограничения: «Не используй сторонние библиотеки для UI. Только нативные CSS-модули. Поддержка браузеров: последние 2 версии Chrome, Firefox, Safari.»&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;3.4. Итеративный промптинг&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Почти никогда первый результат не бывает идеальным. Но вместо того чтобы переписывать промпт с нуля, используйте диалог.&lt;/p&gt;

&lt;p&gt;Шаблон: «Результат хороший, но нужно исправить три вещи: (1) сделай отступы между карточками 24px вместо 16px, (2) измени цвет кнопки на акцентный (#F59E0B), (3) добавь состояние hover для карточек. Не меняй ничего больше.»&lt;/p&gt;

&lt;p&gt;Более продвинутый вариант — «аджайл-промптинг»: Разбейте большую задачу на маленькие итерации.&lt;/p&gt;

&lt;ol&gt;
	&lt;li&gt;«Создай скелет страницы: хедер, основная область, футер. Пока без контента.»&lt;/li&gt;
	&lt;li&gt;«Теперь добавь три карточки товаров в основную область. Используй структуру: изображение, название, цена, кнопка.»&lt;/li&gt;
	&lt;li&gt;«Сделай карточки адаптивными: на десктопе — 3 колонки, на планшете — 2, на мобильном — 1.»&lt;/li&gt;
	&lt;li&gt;«Теперь добавь интерактив: при наведении на карточку — лёгкая тень и увеличение на 2% (transition 200ms).»&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;strong&gt;3.5. Негативный промптинг (Negative prompting)&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Скажите AI не только что делать, но и что категорически нельзя.&lt;/p&gt;

&lt;p&gt;Для генерации изображений (Midjourney, DALL-E):&lt;/p&gt;

&lt;p&gt;Лендинг для IT-конференции. --no gradients, drop shadows, neon colors, 3D elements, stock photos, serif fonts, rounded corners on buttons&lt;/p&gt;

&lt;p&gt;Для кода:&lt;/p&gt;

&lt;p&gt;Создай хук useLocalStorage. Требования:&amp;nbsp;&lt;/p&gt;

&lt;p&gt;- НЕ используй try/catch (обработку ошибок я добавлю сам)&lt;br /&gt;
- НЕ используй useEffect для инициализации&lt;br /&gt;
- НЕ используй any в TypeScript&lt;br /&gt;
- НЕ генерируй лишних ререндеров&lt;/p&gt;

&lt;h2&gt;Часть 4. Промпты для дизайна: практические шаблоны&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;4.1. Генерация UI-компонента&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Роль: senior UI-дизайнер, специалист по доступным интерфейсам.&lt;/p&gt;

&lt;p&gt;Задача: создать карточку профиля пользователя для мобильного приложения соцсети.&lt;/p&gt;

&lt;p&gt;Контекст: приложение для людей 35+, цель — общение по интересам. Интерфейс должен быть понятным, без "молодёжного" дизайна.&lt;/p&gt;

&lt;p&gt;Требования:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Компоновка: аватар (слева), имя и статус (центр), кнопка "Написать" (справа).&lt;/li&gt;
	&lt;li&gt;Под аватаром — три иконки с числом друзей, фотографий, постов.&lt;/li&gt;
	&lt;li&gt;Цветовая схема: нейтральная (#F5F5F5 фон, #333 текст), акцент — #0066CC.&lt;/li&gt;
	&lt;li&gt;Адаптив: карточка растягивается на всю ширину экрана, внутренние отступы 16px.&lt;/li&gt;
	&lt;li&gt;Анимация: при нажатии на карточку — лёгкий ripple-эффект.&lt;/li&gt;
	&lt;li&gt;Доступность: контраст 4.5:1 для текста, фокус клавиатуры, атрибуты aria-label для иконок.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Не использовать: фотографии в кружочках (только квадратные с border-radius 12px), градиенты, выносные элементы.&lt;/p&gt;

&lt;p&gt;Верни результат как структуру Figma (слои, компоненты, стили) или как JSON-схему.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;4.2. Генерация дизайн-системы&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Роль: архитектор дизайн-систем.&lt;/p&gt;

&lt;p&gt;Задача: спроектировать дизайн-систему для B2B-платформы управления проектами.&lt;/p&gt;

&lt;p&gt;Требования:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Цвета: основной нейтральный (серый), акцентный (синий), предупреждения (жёлтый), ошибки (красный), успех (зелёный). Каждый цвет — в 10 градациях.&lt;/li&gt;
	&lt;li&gt;Типографика: системные шрифты, 7 уровней заголовков (от H1 до H7), 4 уровня текста. Метрики: line-height, letter-spacing.&lt;/li&gt;
	&lt;li&gt;Сетка: 12-колоночная на десктопе, 8 — на планшете, 4 — на мобильном. Отступы: 8, 16, 24, 32, 48, 64px.&lt;/li&gt;
	&lt;li&gt;Компоненты: кнопки (4 варианта), инпуты (3 состояния), карточки, модалки, тултипы, таблицы, дропдауны. Для каждого — все состояния (default, hover, active, disabled, loading, error).&lt;/li&gt;
	&lt;li&gt;Анимации: 5 стандартных easing-функций, длительности (100, 200, 300, 500ms).&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Выдай результат как структуру JSON с полями: colors, typography, spacing, components, animations.&lt;/p&gt;

&lt;h2&gt;Часть 5. Промпты для кода: практические шаблоны&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;5.1. Генерация React-компонента&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Роль: senior фронтенд-разработчик, фанатик TypeScript и производительности.&lt;/p&gt;

&lt;p&gt;Задача: создать компонент Modal на React + TypeScript с порталом.&lt;/p&gt;

&lt;p&gt;Контекст: используется в дашборде с тяжёлыми графиками. Важна производительность и отсутствие лишних ререндеров.&lt;/p&gt;

&lt;p&gt;Требования:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Props: isOpen (boolean), onClose (() =&amp;gt; void), title (string), children (ReactNode), size ("sm" | "md" | "lg" | "full"), closeOnOverlayClick (boolean, default true).&lt;/li&gt;
	&lt;li&gt;При открытии — блокировка скролла body.&lt;/li&gt;
	&lt;li&gt;Закрытие: по Escape, клику на оверлей (если closeOnOverlayClick=true), кнопке "X".&lt;/li&gt;
	&lt;li&gt;Анимация: появление/исчезновение через CSS transition (opacity, transform). Длительность 200ms.&lt;/li&gt;
	&lt;li&gt;Доступность: role="dialog", aria-modal="true", focus trap (фокус не уходит из модалки), возврат фокуса при закрытии.&lt;/li&gt;
	&lt;li&gt;Технические ограничения: без внешних библиотек (кроме React и react-dom). Используй createPortal. CSS Modules.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Выдай полный код компонента с комментариями, объясняющими ключевые решения.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;5.2. Генерация хука&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Роль: lead разработчик, специалист по пользовательским хукам.&lt;/p&gt;

&lt;p&gt;Задача: написать хук useDebounce.&lt;/p&gt;

&lt;p&gt;Требования:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Типизация: &amp;lt;T&amp;gt;(value: T, delay: number) =&amp;gt; T&lt;/li&gt;
	&lt;li&gt;Возвращает дебаунснутое значение.&lt;/li&gt;
	&lt;li&gt;Сброс таймера при размонтировании.&lt;/li&gt;
	&lt;li&gt;Поддержка опции immediate: если true — значение обновляется сразу, а потом игнорируется указанное время.&lt;/li&gt;
	&lt;li&gt;Использовать useRef для хранения таймера, useEffect для подписки/отписки.&lt;/li&gt;
	&lt;li&gt;Обработка edge cases: delay &amp;lt;= 0, изменение delay на лету, очистка при быстром переключении компонента.&lt;/li&gt;
	&lt;li&gt;JSDoc для каждого параметра.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Пример использования:&lt;br /&gt;
const [searchTerm, setSearchTerm] = useState('')&lt;br /&gt;
const debouncedSearch = useDebounce(searchTerm, 300, { immediate: false })&lt;/p&gt;

&lt;p&gt;Выдай код хука + пример использования в компоненте SearchInput.&lt;/p&gt;

&lt;h2&gt;Часть 6. Инструменты для промпт-инжиниринга&lt;/h2&gt;

&lt;p&gt;Писать хорошие промпты помогает не только голова, но и специальные инструменты.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Для работы с текстовыми AI (ChatGPT, Claude, Gemini)&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;PromptPerfect — оптимизирует ваши промпты, предлагая улучшения для конкретной модели.&lt;/li&gt;
	&lt;li&gt;LangChain — фреймворк для создания цепочек промптов, памяти и инструментов.&lt;/li&gt;
	&lt;li&gt;Anthropic Console — встроенные шаблоны и режим "chain of thought" для Claude.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Для дизайна&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Figma AI — плагины вроде "Design System Prompter" помогают переводить текстовые требования в дизайн-токены.&lt;/li&gt;
	&lt;li&gt;Midjourney Prompt Helper — конструктор промптов с подсказками по стилям, параметрам и весам.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Для кода&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Cursor и Continue — AI-ассистенты, которые умеют работать с промптами прямо в редакторе кода, включая few-shot examples из ваших файлов.&lt;/li&gt;
	&lt;li&gt;Aider — утилита командной строки для промпт-инжиниринга в Git-репозиториях.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;Часть 7. Заключение: промпт-инжиниринг как образ мышления&lt;/h2&gt;

&lt;p&gt;Промпт-инжиниринг — это не просто набор техник. Это способ мышления.&lt;/p&gt;

&lt;p&gt;Хороший промптист (а в 2026 году каждый уважающий себя дизайнер и разработчик должен им быть) мыслит как:&lt;/p&gt;

&lt;ul&gt;
	&lt;li&gt;Инженер — чётко, структурированно, с учётом ограничений.&lt;/li&gt;
	&lt;li&gt;Психолог — понимает, как AI интерпретирует слова, и выбирает формулировки, исключающие двусмысленность.&lt;/li&gt;
	&lt;li&gt;Коммуникатор — умеет объяснить сложную задачу простыми словами, но с нужной степенью детализации.&lt;/li&gt;
	&lt;li&gt;Итератор — не ждёт идеального результата с первого раза, а последовательно улучшает его через диалог.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Главный совет на прощание:&lt;/p&gt;

&lt;p&gt;Не думайте о промпте как о «магическом заклинании». Это техническое задание, которое вы пишете для очень умного, но буквально мыслящего стажёра.&lt;/p&gt;

&lt;p&gt;Чем точнее и полнее вы опишете контекст, роли, требования и ограничения — тем меньше «магии» потребуется, чтобы результат оказался полезным. И тем больше времени вы сэкономите на бесконечных правках.&lt;/p&gt;

&lt;p&gt;Помните: AI делает то, что вы сказали, а не то, что вы имели в виду. Ваша задача — исключить разрыв между этими двумя понятиями. И хороший промпт — это единственный инструмент, который это позволяет.&lt;br /&gt;
&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;

&lt;p&gt;&amp;nbsp;&lt;/p&gt;</summary>
    <dc:creator>Алексей Кондратьев</dc:creator>
    <dc:date>2026-07-07T14:49:00Z</dc:date>
  </entry>
  <entry>
    <title>Циклическое кодирование времени для прикладных задач</title>
    <link rel="alternate" href="https://www.tune-it.ru/c/blogs/find_entry?entryId=21275800" />
    <author>
      <name>Никита Рогаленко</name>
    </author>
    <id>https://www.tune-it.ru/c/blogs/find_entry?entryId=21275800</id>
    <updated>2026-07-03T10:00:03Z</updated>
    <published>2026-07-03T10:00:00Z</published>
    <summary type="html">&lt;p style="text-align: justify;"&gt;Сегодня мы поговорим о простом, но действенном математическом способе преобразования данных о времени из линейного промежутка в окружность, имитирующую циферблат часов. Необходимость таких трансформаций появляется в тех случаях, когда алгоритму машинного обучения или разрабатываемому нами сервису важно понимать, что время в сутках идет по кругу и что разница в отметках (например, времени входа) 23:59 и 00:01 незначительная. Подобным образом происходит трансформация&amp;nbsp;периодических временных признаков (не только часы, но и дни, месяцы) в непрерывные числовые значения, сохраняющие связь между концом и началом цикла. Это может использоваться, скажем, при обнаружении аномалий в поведении пользователя. Так, при моделировании профиля поведения нам важно знать, что активность, происходящая в ночь с одного дня на другой, принадлежит примерно к одному промежутку времени, а не к противоположным на временной оси точкам. Кроме того, применяться метод может при прогнозировании сезонных значений разного рода признаков от погоды и климата до числа продаж.&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;Итак, каким же образом мы можем&amp;nbsp;проецировать время на окружность, где 23:00 и 00:00 окажутся&amp;nbsp;рядом?&amp;nbsp;Для любого временного признака расчет выполняется через перевод значения в радианы внутри текущего цикла по формулам:&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/20567281/sincos.png/4e860ccb-cfe7-e264-f160-1b90694fb09e?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;В этих формулах:&lt;/p&gt;

&lt;ul&gt;
	&lt;li style="text-align: justify;"&gt;t -&amp;nbsp;текущее значение времени:&amp;nbsp;час (0-23), месяц (1-12), день недели (0-6 или 1-7) и т.п.&lt;/li&gt;
	&lt;li style="text-align: justify;"&gt;T -&amp;nbsp;максимальный период цикла, т.е. количество делений в периоде: 24 для часов в сутках&amp;nbsp;(можно на 60 умножить для минут), 12 для месяцев, 7 для дней недели и т.п.&lt;/li&gt;
&lt;/ul&gt;

&lt;p style="text-align: justify;"&gt;Для примера возьмем случай, когда нам нужно анализировать время входа в приложение в часах и минутах. Покажем, как 23:15 и 00:45 в случае кодирования через синусы и косинусы оказываются примерно в одной области нашей воображаемой временной окружности. В первую очередь, переведем часы в минуты от начала суток (это будет значение t). В таком случае&amp;nbsp;23:15 превратится в 1395 минут, а&amp;nbsp;00:45 соответственно в 45 минут. Значение T в таком&amp;nbsp;случае будет 24*60=1440 минут.&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;Далее по формулам выше рассчитаем, что для 23:15:&lt;/p&gt;

&lt;ul&gt;
	&lt;li style="text-align: justify;"&gt;x&lt;sub&gt;sin&lt;/sub&gt;&amp;nbsp;= -0,195&lt;/li&gt;
	&lt;li style="text-align: justify;"&gt;x&lt;sub&gt;cos&lt;/sub&gt;&amp;nbsp;= 0,981&lt;/li&gt;
	&lt;li style="text-align: justify;"&gt;Итоговые координаты для кодирования времени: (x&lt;sub&gt;cos&lt;/sub&gt;&amp;nbsp;;&amp;nbsp;x&lt;sub&gt;sin&lt;/sub&gt;) = (0,981; -0,195)&lt;/li&gt;
&lt;/ul&gt;

&lt;p style="text-align: justify;"&gt;Для 00:45:&lt;/p&gt;

&lt;ul&gt;
	&lt;li style="text-align: justify;"&gt;x&lt;sub&gt;sin&lt;/sub&gt;&amp;nbsp;= 0,195&lt;/li&gt;
	&lt;li style="text-align: justify;"&gt;x&lt;sub&gt;cos&lt;/sub&gt;&amp;nbsp;= 0,981&lt;/li&gt;
	&lt;li style="text-align: justify;"&gt;Итоговые координаты для кодирования времени: (x&lt;sub&gt;cos&lt;/sub&gt;&amp;nbsp;;&amp;nbsp;x&lt;sub&gt;sin&lt;/sub&gt;) = (0,981; 0,195)&lt;/li&gt;
&lt;/ul&gt;

&lt;p style="text-align: justify;"&gt;Примерно так это будет выглядеть на тригонометрическом круге, имитирующем циферблат часов:&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;&lt;img src="https://www.tune-it.ru/documents/portlet_file_entry/20567281/sincos_circle.png/275e18ee-90c6-d0ea-efc1-364cec0f1471?imagePreview=1" /&gt;&lt;/p&gt;

&lt;p style="text-align: justify;"&gt;Как мы видим, 23:15 и 00:45&amp;nbsp;оказались достаточно близко, расстояние между ними небольшое (длина хорды около 0,4, тогда как для полуночи и полудня как самых отдаленных точек оно равняется 2,0). В связи с этим модель поймет, что данные временные отметки располагаются достаточно близко друг к другу, что события происходят примерно в одно время, тем самым&amp;nbsp;существенно повышая&amp;nbsp;точность решаемой задачи. Программная реализация в общем случае также не является сложной. Типичный пример кода на Python:&lt;/p&gt;

&lt;pre class="brush:python;"&gt;
import numpy as np

def encode_time_with_minutes(time_str):
    hours, minutes = map(int, time_str.split(':'))
    t = hours * 60 + minutes
    T = 24 * 60 
    sin_val = np.sin(2 * np.pi * t / T)
    cos_val = np.cos(2 * np.pi * t / T)
    return round(cos_val, 3), round(sin_val, 3)

print("23:15 -&amp;gt;", encode_time_with_minutes("23:15"))
print("00:45 -&amp;gt;", encode_time_with_minutes("00:45"))&lt;/pre&gt;

&lt;p style="text-align: justify;"&gt;Безусловно у этого метода есть и недостатки. Так, для кодирования временной отметки обязательно нужно два значения вместо одного (синус и косинус), а расстояние между точками на окружности растет нелинейно по мере удаления друг от друга. Данный метод подходит не для всех алгоритмов и методов машинного обучения, однако во многих случаях он все же предоставляет рабочее и элегантное решение для проблем преобразования временных отметок в циклическую форму.&lt;/p&gt;</summary>
    <dc:creator>Никита Рогаленко</dc:creator>
    <dc:date>2026-07-03T10:00:00Z</dc:date>
  </entry>
</feed>

