Тонкая грань между state management и overengineering во фронтенде
Текст написан с позиции июня 2020 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
К середине 2020 года разговоры о state management во фронтенде уже давно перестали быть уделом узкого круга энтузиастов. Почти любая команда, которая делает не лендинг, а более или менее насыщенное интерфейсами приложение, в какой-то момент приходит к одному и тому же вопросу: как хранить состояние так, чтобы проект не развалился через полгода. И почти сразу рядом появляется другой вопрос, гораздо менее приятный: а не начинаем ли мы строить слишком сложную архитектуру раньше, чем она действительно нужна?
Это и есть та самая тонкая грань, на которой сегодня стоит добрая половина фронтенд-разработки. С одной стороны, хаотичное состояние — один из самых надежных способов превратить приложение в источник багов, дублирования логики и тяжелых для воспроизведения сценариев. С другой — попытка «сделать все правильно» нередко приводит к тому, что в приложении на пять экранов появляются action creators, reducers, selectors, middleware, сервисные слои, фабрики адаптеров, нормализованные сущности и абстракции поверх абстракций, хотя бизнесу всего лишь нужно, чтобы список товаров фильтровался, корзина не сбрасывалась и модальное окно открывалось по кнопке.
Самое интересное в этой теме то, что обе крайности обычно возникают из хороших намерений. Разработчик, который не думает о состоянии вовсе, редко хочет написать плохую систему. Чаще он просто идет кратчайшим путем: поднял компонент, положил данные в local state, пробросил пару props, добавил callback, потом еще один, потом чуть-чуть вынес логику в helper — и вроде бы все работает. Разработчик, который строит сложную инфраструктуру вокруг состояния, тоже не обязательно увлекся сложностью ради красоты. Он, как правило, уже видел проекты, где все разъехалось, и теперь пытается не допустить повторения. Проблема в том, что опыт прошлого хаоса иногда заставляет заранее закладывать решения для масштаба, которого у текущего проекта может никогда не быть.
Поэтому разговор о state management почти никогда не должен начинаться с вопроса «Redux или Context?», «MobX или hooks?», «локальное состояние или глобальное хранилище?». Эти вопросы слишком быстро переводят обсуждение на язык инструментов. Куда полезнее сначала задать вопрос другого уровня: какие именно проблемы состояния у нас есть прямо сейчас, и какие, с высокой вероятностью, появятся в ближайшее время? Пока команда не умеет на него честно отвечать, любое решение рискует оказаться либо слишком слабым, либо слишком тяжелым.
Почему тема состояния так быстро выходит из-под контроля
Во фронтенде состояние почти всегда кажется чем-то локальным и невинным, пока приложение маленькое. Есть форма — у нее есть поля. Есть таблица — у нее есть пагинация и сортировка. Есть модальное окно — у него есть флаг открытия. По отдельности все это выглядит просто. Но приложение редко растет по одной прямой линии. Обычно оно обрастает связями. Фильтр влияет на список. Выбор в списке влияет на панель деталей. Панель деталей может открыть редактор. Редактор должен обновить список. Список может быть кэширован. Параллельно есть авторизация, глобальные уведомления, права доступа, сохранение части пользовательских настроек между перезагрузками страницы. И вот уже становится неясно, что из этого должно жить внутри конкретного компонента, что — на уровне страницы, а что — в общем контейнере состояния приложения.
Сложность здесь не столько в объеме данных, сколько в количестве зависимостей между ними. Чем больше один кусок интерфейса знает о другом, тем выше вероятность, что изменение в одном месте сломает что-то в другом. Поэтому state management на практике — это не только про «где хранить данные», но и про «где проходят границы ответственности». Если эти границы не определены, состояние начинает течь через приложение как вода через трещины: через props, closures, контексты, глобальные синглтоны, временные переменные, URL, localStorage и бог знает что еще.
Именно в этот момент появляется соблазн взять «серьезный» инструмент и централизовать все. В этом есть логика. Но именно здесь и лежит первая ловушка overengineering: желание решить не конкретную проблему, а всю категорию проблем разом. В теории это звучит солидно. На практике нередко означает, что вместо одной понятной трудности команда получает целую новую систему правил, которую теперь нужно поддерживать.
Нормальная реакция на хаос — не всегда сложная архитектура
Когда разработчик впервые сталкивается с беспорядочным состоянием, вывод кажется очевидным: нужно единое хранилище, строгие правила обновления, неизменяемость, предсказуемые переходы, возможно, еще слой селекторов и раздельные контейнерные компоненты. Но самая вредная реакция на хаос — услышать слово «беспорядок» и решить, что лекарство всегда тяжелое. Хаос не всегда требует тяжелого ответа. Иногда проблема не в отсутствии глобального store, а в отсутствии дисциплины на более базовом уровне.
Очень многие фронтенд-проекты начинают страдать раньше, чем у них появляется настоящий запрос на развитый state management. Они страдают потому, что данные дублируются в нескольких местах. Потому что одни и те же вычисления размазаны по компонентам. Потому что UI-состояние смешано с серверными данными. Потому что компонент знает слишком много о способе загрузки данных, а страница — слишком много о внутреннем устройстве дочерних элементов. В таких случаях добавление сложного инструмента может даже ухудшить ситуацию: архитектурный шум увеличится, а исходная неразбериха останется.
Другими словами, overengineering часто начинается не там, где команда выбрала «не ту библиотеку», а там, где она пытается компенсировать инструментом отсутствие ясной модели приложения. Если не понятно, что является состоянием интерфейса, что — кэшем данных, что — производным вычислением, а что — просто временным флагом, никакой store сам по себе не наведет порядок.
Первый вопрос: это вообще state или просто данные на экране?
Это кажется мелочью, но именно отсюда начинается большое количество ненужных архитектурных решений. В приложении есть множество значений, но далеко не все они заслуживают одинакового отношения. Есть данные, которые пришли с сервера и лишь отображаются. Есть UI-состояние: открыта ли панель, какой таб выбран, какое поле сейчас в фокусе. Есть производные значения: отфильтрованный список, количество выбранных элементов, флаг «можно ли отправить форму». Есть долговременные пользовательские предпочтения. Есть временные данные, живущие ровно до размонтирования компонента.
Когда все это мысленно сваливается в одну кучу под названием «state», архитектура начинает раздуваться. Разработчик тащит в общее хранилище то, что могло спокойно жить внутри одного компонента. Или наоборот — оставляет локально то, что уже давно стало общей заботой нескольких независимых участков интерфейса. Хороший state management начинается не с инструмента, а с умения различать природу данных.
Например, значение поля поиска на конкретной странице вполне может быть локальным состоянием компонента верхнего уровня. Но если тот же поиск должен синхронизироваться с URL, восстанавливаться при возврате назад, влиять на несколько независимых блоков страницы и переживать навигацию, это уже совсем другой класс задачи. Точно так же флаг открытия одной модалки редко нуждается в глобальном store. А вот состояние авторизации, профиль пользователя и набор его прав — почти всегда выходят за пределы локального компонента.
Главный симптом overengineering: решение стало важнее задачи
У overengineering есть узнаваемый запах. Он появляется там, где обсуждение состояния начинает вращаться вокруг структуры решения, а не вокруг пользовательского сценария. Команда много говорит о слоях, паттернах и правильном потоке данных, но все меньше — о том, какие реальные проблемы это все снимает. Возникают конструкции, которые выглядят очень системно, но почти не уменьшают сложность конкретной фичи.
Характерный пример — когда для элементарного изменения интерфейса приходится создавать слишком длинную цепочку сущностей. Допустим, пользователь нажимает кнопку «развернуть блок». И внезапно это действие превращается в dispatch, action type, reducer case, selector, mapState, обертку контейнера и еще пару вспомогательных сущностей. Формально все красиво и консистентно. Но если цена такой операции выше, чем ценность формального единообразия, стоит задуматься: а не пересекли ли мы ту самую грань?
Важно понимать, что overengineering — это не просто «слишком много кода». Иногда сложная система действительно оправданна. Overengineering начинается там, где стоимость поддержки решения становится выше, чем стоимость проблем, которые оно решает. Это всегда вопрос соотношения, а не абсолютного количества файлов.
Слишком ранняя централизация — частая ошибка
Во многих командах уже накопился устойчивый рефлекс: если приложение похоже не на сайт-визитку, а на «настоящий сервис», надо как можно раньше вводить централизованный state management. Этот рефлекс понятен. Централизация обещает предсказуемость. Но проблема не в том, что централизация плоха, а в том, что преждевременная централизация — один из самых популярных способов усложнить фронтенд до того, как он успел вырасти естественным образом.
Проблема в том, что глобальное хранилище создает не только преимущества, но и новую гравитацию. Все начинает тянуться в центр просто потому, что центр есть. Туда попадают мелкие UI-флаги, промежуточные значения форм, одноразовые состояния локальных виджетов, особенности конкретной страницы. Через некоторое время store перестает быть отражением общей модели приложения и становится складом всего подряд. А когда в одном месте лежит слишком многое, управлять зависимостями становится не проще, а труднее.
Централизация хороша там, где действительно есть общая правда, важная для нескольких частей приложения. Авторизация, текущий пользователь, глобальные permissions, кэш определенных сущностей, общие уведомления, параметры, которые определяют поведение нескольких независимых экранов, — вот здесь общий слой вполне оправдан. Но если не различать общую правду и частную механику конкретного UI-узла, глобальное состояние быстро превращается в бутылочное горлышко.
Локальное состояние не признак слабой архитектуры
Во фронтенд-кругах есть странная, но довольно живучая мысль: чем больше логики вынесено из компонентов в «серьезные» слои, тем зрелее архитектура. На практике это не так. Умение оставлять состояние локальным, когда оно действительно локальное, — скорее признак зрелости, чем недостатка системности.
React-компонент не обязан быть тупым визуальным листком бумаги, который умеет только принимать props и рендерить JSX. Вполне естественно, что у него есть внутреннее состояние, связанное с его жизненным циклом и поведением. Более того, попытка насильно вынести такие вещи наружу может сделать код менее читаемым. Когда состояние живет рядом с местом использования, причинно-следственные связи часто видны лучше.
Проблемы начинаются не из-за самого локального состояния, а из-за того, что оно остается локальным слишком долго, несмотря на явные признаки того, что уже обслуживает несколько контекстов. Если одно и то же значение приходится поднимать все выше и выше, если props drilling становится мучительным, если несколько независимых веток дерева должны реагировать на один источник правды, если состояние нужно восстанавливать при навигации или шарить между страницами, — тогда да, локальный подход упирается в пределы. Но до этого момента нет ничего плохого в том, чтобы дать состоянию жить там, где ему проще и естественнее.
Нельзя одинаково обращаться с UI-state и server-state
Одна из наиболее неприятных ошибок проектирования — складывать в одну корзину состояние интерфейса и данные, которые приходят с сервера. Эти две категории похожи только на поверхности. По своей природе они разные. UI-state управляет тем, как интерфейс ведет себя здесь и сейчас. Server-state живет по другим законам: он загружается асинхронно, может быть устаревшим, требует повторной синхронизации, кэширования, обработки ошибок и стратегий обновления.
Когда эти типы состояния не различаются, в приложении появляются странные компромиссы. Логика загрузки начинает зависеть от флагов модалок. Данные сущностей размазываются по компонентам в виде копий и локальных снапшотов. Обновление одной записи требует ручного обхода нескольких мест, где она «еще где-то лежит». В результате команда думает, что борется за единое хранилище, а на деле лишь накапливает дубли.
Даже если вы не используете специальные библиотеки для работы с серверными данными, полезно на уровне мышления разводить эти категории. Спросить себя: это наш собственный интерфейсный state или это отражение удаленного источника, с которым надо уметь жить в условиях задержек, ошибок и устаревания? Очень часто уже одна эта мысль позволяет убрать половину лишних архитектурных решений.
Абстракции нужны там, где есть повторение, а не там, где есть страх
Еще одна характерная черта overengineering — создание абстракций «на будущее». Разработчик опасается, что приложение вырастет, и заранее строит универсальные слои для сценариев, которые пока существуют лишь в воображении. Появляются общие менеджеры состояния для двух компонентов, которые пока еще даже не похожи друг на друга. Возникают интерфейсы для смены хранилища, хотя никто не собирается его менять. Добавляется нормализация данных там, где сущностей мало и связи просты. Все это делается из страха перед возможной будущей болью.
Но страх — плохой источник архитектурных решений. Абстракция становится полезной не тогда, когда можно придумать гипотетическую причину для ее существования, а тогда, когда в коде уже есть устойчивый паттерн повторения или реальная вариативность. До этого момента абстракция обычно не уменьшает сложность, а просто распределяет ее по большему числу мест.
Это особенно заметно во фронтенде, где цена изменения часто ниже, чем кажется. Да, иногда правильнее заложить каркас заранее. Но гораздо чаще дешевле сначала дать задаче проявить свою реальную форму, а уже потом обобщать. Когда за плечами у команд уже есть опыт нескольких волн «идеальных архитектур», становится особенно полезно помнить: не каждая потенциальная проблема заслуживает немедленного структурного ответа.
Признаки того, что state management действительно нужен сильнее
Чтобы не скатиться ни в наивность, ни в избыточность, полезно обращать внимание не на идеологию, а на симптомы. Есть вполне практические признаки, что приложению нужен более выраженный подход к управлению состоянием.
Первый признак — одни и те же данные становятся значимыми для нескольких удаленных друг от друга частей интерфейса. Второй — обновления этих данных должны быть согласованными и предсказуемыми, а ручная синхронизация начинает давать сбои. Третий — бизнес-логика переходов состояния становится заметной: не просто «true/false», а последовательность разрешенных сценариев, ошибок и побочных эффектов. Четвертый — становится важно понимать, почему состояние оказалось в том или ином виде, а не просто хранить его. Пятый — появляются требования к воспроизводимости, отладке, журналированию, возможно, к time-travel или хотя бы к прозрачному трассированию изменений.
Когда эти симптомы есть, более строгий state management перестает быть теоретической красотой и становится рабочим инструментом. Но заметим, что даже здесь речь не идет автоматически о самой сложной доступной архитектуре. Речь идет лишь о том, что интуитивного локального подхода уже недостаточно.
Признаки того, что вы уже перегнули
Есть и обратные сигналы, на которые стоит смотреть без самообмана. Если для большинства UI-изменений нужно трогать слишком много сущностей и проходить через длинный формальный ритуал, это тревожный знак. Если новый разработчик понимает пользовательский сценарий только после чтения шести файлов и двух вспомогательных абстракций — это тоже тревожный знак. Если большая часть архитектуры объясняется фразами вроде «потом пригодится», «так масштабируемее», «зато единообразно», но команда не может назвать конкретные сегодняшние проблемы, которые это снимает, — вероятность overengineering очень высока.
Еще один важный симптом: когда изменение простой фичи требует не меньше архитектурного сопровождения, чем сама бизнес-логика. Это особенно болезненно в продуктовой разработке, где интерфейс часто меняется. Если каждое небольшое решение тонет в слоях, согласованиях и инфраструктурном коде, команда начинает тратить больше энергии на поддержание формы, чем на развитие продукта.
Overengineering коварен тем, что поначалу выглядит как профессионализм. Система кажется «взрослой». Но через некоторое время выясняется, что скорость изменения упала, а ясности не прибавилось.
Инструмент не должен диктовать модель приложения
В обсуждениях state management очень легко попасть под влияние инструмента. Любая популярная библиотека несет с собой определенную философию и стиль мышления. Это нормально. Проблема начинается тогда, когда команда начинает формировать модель приложения под удобства инструмента, а не наоборот.
Если разработчики выбирают подход и затем начинают искусственно разрезать или склеивать состояние так, чтобы оно «хорошо ложилось» в библиотеку, это почти всегда ведет к искажению. Инструмент должен помогать обслуживать реальные зависимости приложения. Он не должен превращаться в источник этих зависимостей.
Поэтому зрелый выбор state management — это не «какая библиотека сейчас популярнее», а «какой подход минимальной ценой решит наши актуальные задачи и оставит пространство для роста». Иногда ответом будет локальный state плюс аккуратная композиция. Иногда — Context для ограниченной области. Иногда — Redux или другой централизованный механизм. Иногда — комбинация нескольких подходов. И в этом нет идеологического предательства. Есть только соответствие реальности проекта.
Состояние — это часть модели продукта, а не отдельный технический слой
Очень полезно смотреть на state management не как на инфраструктуру, которую можно прикрутить сверху, а как на отражение продукта в коде. Если модель продукта ясна, структура состояния обычно тоже начинает проясняться. Какие у пользователя есть режимы работы? Какие сущности долговременны? Какие действия изменяют их? Что зависит от навигации, а что — от сессии? Что является источником истины, а что вычисляется на лету?
Когда архитектура состояния строится от этих вопросов, шанс на overengineering заметно снижается. Потому что тогда вы не пытаетесь внедрить абстрактную «правильную систему управления состоянием», а проектируете конкретную форму поведения продукта. А продукт, как правило, сам подсказывает, где нужна строгость, а где достаточно простоты.
Парадоксально, но одна из самых сильных профилактик избыточной архитектуры — хорошее понимание предметной области. Там, где команда ясно представляет, как живет интерфейс и какие пользовательские сценарии действительно важны, она гораздо реже строит тяжелые конструкции из одного лишь желания «сделать по-умному».
Простота не означает отсутствие системы
Иногда, критикуя overengineering, люди невольно впадают в другую крайность и начинают прославлять любую простоту как благо само по себе. Но простота тоже бывает разной. Есть простота продуманная, когда границы ответственности ясны, зависимости минимальны, а решение соответствует масштабу задачи. А есть простота мнимая, когда сегодня код выглядит коротким только потому, что сложность еще не получила своей формы.
Хороший state management не обязан быть массивным, но он почти всегда требует дисциплины мышления. Нужно понимать, что от чего зависит. Нужно не дублировать данные без причины. Нужно отделять источник истины от производных представлений. Нужно учитывать жизненный цикл данных. Нужно честно признавать, когда локальное состояние уже стало общим. Это тоже система, просто не обязательно выраженная в тяжелом наборе абстракций.
Поэтому вопрос не в том, чтобы «избегать архитектуры». Вопрос в том, чтобы не строить архитектуру ради самоуспокоения. Самые устойчивые решения обычно выглядят почти скромно: в них нет ощущения показной монументальности, зато есть ясность и соразмерность.
Правильная грань всегда контекстная
Тонкая грань между state management и overengineering не проходит по названию библиотеки и не определяется количеством reducer’ов или hooks. Она проходит в другом месте: между реальной сложностью продукта и сложностью решения, которое команда вокруг него строит. Когда решение по масштабу и строгости соответствует характеру задачи, архитектура помогает. Когда оно начинает жить собственной жизнью и требовать обслуживания ради самого себя, начинается перегиб.
Во фронтенде к лету 2020 года уже достаточно накопленного опыта, чтобы признать простую вещь: нет универсальной добродетели в тотальной централизации, как нет добродетели и в полном отказе от системного управления состоянием. Есть конкретный проект, его темп роста, его команда, его интерфейсные сценарии, его данные и его цена изменений. Именно это должно определять, насколько тяжелым или легким будет выбранный подход.
И, возможно, самый полезный практический ориентир здесь такой: каждый новый слой state management должен уменьшать когнитивную нагрузку, а не увеличивать ее. Если после введения очередной архитектурной идеи команде стало легче понимать, где живет правда, почему состояние меняется и как расширять систему, значит, решение, вероятно, оправдано. Если же стало больше формальных сущностей, но меньше ясности, значит вы, скорее всего, уже шагнули в сторону overengineering.
Во фронтенде вообще многое соблазняет строить «с запасом». Но хороший запас — это не максимальное количество абстракций, а правильный запас ясности. Все остальное почти всегда можно достроить позже, когда станет действительно нужно.