Frontend-архитектура 2020: что пережило хайп, а что уже лучше не тащить в новый проект

•
Опубликовано
•
15 мин чтения

Текст написан с позиции декабря 2020 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.

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

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

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

При этом важно не впадать в другую крайность. Самая вредная реакция на усталость от паттернов — услышать, что многие красивые схемы не оправдали себя, и решить, что архитектура вообще не нужна или что достаточно просто писать «как идет». Это ложный вывод. Наоборот, к концу 2020 года стало заметно яснее, что хорошая frontend-архитектура — это не набор священных слоев и не культ какой-то конкретной библиотеки, а система границ. Где хранится правда. Что считается UI-состоянием, а что данными приложения. Где заканчивается ответственность компонента. Как организованы зависимости. Что можно менять локально, а что тянет за собой половину проекта. Именно эти вопросы и отделяют устойчивую систему от набора удачных временных решений.

Компонентное мышление точно пережило хайп

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

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

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

Композиция вместо наследования — уже не лозунг, а обычная практика

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

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

Иными словами, пережила не просто красивая теория, а конкретная дисциплина: собирать интерфейс из выразимых частей, не создавая гигантских базовых сущностей «на будущее». На фоне множества архитектурных волн это выглядит почти скучно. Но именно скучные полезные вещи и оказываются самыми живучими.

Hooks пережили стадию сенсации и стали частью нормального мышления

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

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

Но вместе с этим стало ясно и то, что hooks не являются автоматической архитектурной благодатью. Ими очень легко произвести новый тип хаоса, если тащить слишком много ответственности в один кастомный hook или превращать его в полускрытый сервис со множеством побочных эффектов. Пережил хайп не тезис «теперь все надо делать через hooks», а более спокойная идея: логика может быть переиспользуемой и локально выразимой без лишней церемонии. Это действительно осталось ценным.

UI-state и server-state наконец перестали складывать в одну корзину

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

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

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

Локальность как ценность — и это очень хороший сигнал

Несколько лет назад во фронтенде было довольно легко создать впечатление, что зрелое приложение — это обязательно приложение с сильной централизацией почти всего. Глобальные store, единые шины, многоступенчатые потоки изменений, обязательная выносная логика даже для вещей, которые по своей природе были локальными. Все это обещало предсказуемость, но на практике часто превращалось в перегрузку.

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

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

Дизайн-системы пережили моду, когда их перестали строить впрок

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

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

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

Контейнеры и presentational-компоненты: полезная мысль, но уже без культа

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

Но уже довольно очевидно, что тащить этот паттерн в новый проект в догматической форме не стоит. Он хорош как ориентир, а не как строгая обязанность для каждого компонента. Реальная жизнь интерфейса сложнее бинарного деления. Есть компоненты, которым естественно иметь немного локального поведения и при этом оставаться в основном визуальными. Есть страницы, где уровень координации данных не укладывается в простую схему «контейнер сверху, тупые дети снизу». Есть hooks, которые изменили способ выноса поведения и сделали часть старых оберток менее нужной.

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

Фетишизацию глобального store в новый проект лучше не тащить

Пожалуй, один из самых явных кандидатов на пересмотр — привычка складывать в глобальное хранилище буквально все. Был период, когда это считалось почти обязательным признаком серьезной архитектуры. Если состояние не попадало в общий поток, значит, якобы недоставало дисциплины. На практике это приводило к чудовищному разрастанию store, ритуалам ради ритуалов и постоянному вопросу: почему элементарное изменение UI требует такого количества сопроводительного кода?

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

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

Не стоит тащить и чрезмерную церемониальность вокруг простых действий

Еще один подход, который заметно устал, — это архитектура, в которой даже простое действие пользователя проходит слишком длинный и формальный путь. Нажать кнопку, переключить режим, открыть панель, обновить небольшой кусок состояния — и вдруг вокруг этого возникает целая процессия из action types, action creators, редьюсеров, промежуточных оберток, селекторов и вспомогательных сущностей. Формально такая схема может выглядеть очень стройно. Но если реальная цена изменения становится непропорционально высокой, это плохой знак.

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

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

Универсальные абстракции «на будущее» — тоже кандидат на списание

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

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

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

Многослойность ради самой многослойности тоже заметно подустала

Некоторые команды в погоне за архитектурной серьезностью пытались воспроизвести на фронтенде почти бэкендовые или даже академические модели слоев: domain, application, infrastructure, adapters, facades, presenters и так далее. В определенных больших продуктах и при очень строгой предметной области это может иметь смысл. Но массовое увлечение такой тяжеловесной схемой показало, что во многих интерфейсных проектах цена подобной структуры оказывается слишком высокой.

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

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

Слепая вера в «идеальный паттерн» больше не выглядит зрелой

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

Именно поэтому гораздо взрослее звучит не фраза «мы используем правильную архитектуру X», а вопрос «какие именно проблемы нашей системы это решение упрощает?». Такая постановка разговора менее эффектна, но намного полезнее. Она возвращает архитектуру из зоны идентичности и моды в зону инженерии.

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

Архитектуру стоит мерить управляемостью, а не красотой схемы

Самый полезный вывод из всех качелей последних лет состоит в том, что frontend-архитектура должна оцениваться не по внешней стройности, а по управляемости. Удобно ли вносить изменения. Понятно ли, где искать источник проблемы. Можно ли локально менять часть интерфейса, не рискуя зацепить полпроекта. Есть ли ясность в том, как течет состояние. Можно ли переиспользовать стабильные блоки без насилия над кодом. Насколько быстро новый разработчик начинает понимать систему. Вот настоящие критерии.

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

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

Каким выглядит здоровый новый проект после всех этих выводов

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

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

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

Итог

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

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

Главный урок, пожалуй, довольно простой: хорошая frontend-архитектура не обязана быть громкой. Она должна быть ясной, соразмерной и живучей. Если решение помогает команде двигаться быстрее, понимать систему лучше и менять интерфейс без постоянного страха что-то разломать, значит, оно переживет любой хайп. Все остальное, каким бы модным оно ни было, рано или поздно останется в старых докладах и внутренних вики как память о периоде, когда фронтенд еще слишком любил восхищаться собственной сложностью.

Если сформулировать главный вывод совсем прямо, он будет таким: хайп переживает не самая умная схема, а самая управляемая — компонентная композиция, разведение UI-state и server-state, локальность и hooks как способ выноса поведения без церемоний; а культ глобального store, преждевременные абстракции и многослойность ради солидности дают красивую форму при слишком высокой цене сопровождения и в новый проект их тащить не стоит.

Автор

Senior Principal JavaScript Developer, Tech Lead. Пишет о React, TypeScript, React Native, архитектуре фронтенда и бэкенда и о том, как AI меняет работу разработчика.

Обновлено

Читайте также