React Native в проде: когда общий код между iOS и Android реально окупается

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

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

За последние два с лишним года разговор о React Native успел пройти через все привычные стадии технологической моды. Сначала был восторг. Затем последовала волна слишком смелых обещаний, где JavaScript почти объявлялся универсальным ключом к мобильной разработке. После этого начался более предсказуемый этап — отрезвление, накопление трудных кейсов, раздражение из-за кривых зависимостей, боли при обновлениях, споры о производительности, рассказы о переписывании отдельных модулей на нативном коде и почти обязательный вопрос в каждой дискуссии: а стоит ли оно вообще того в продакшене?

К августу 2017 года этот вопрос уже нельзя обсуждать в режиме теоретического гадания. React Native успел побывать не только на сценах конференций и в MVP, но и в реальных продуктах, и это важная перемена сама по себе. Пока технология живет в демо-примерах, она всегда выглядит стройнее, чем есть на самом деле. В демонстрации нет старого кода, нет компромиссов команды, нет странных требований бизнеса, нет исторически накопленной путаницы между слоями приложения. В проде всё иначе. В проде любая красивая идея проверяется на утомительной повседневности: релизах, дедлайнах, обновлениях библиотек, долгой поддержке и столкновении с реальными пользователями на реальных устройствах.

И вот здесь разговор об «общем коде между iOS и Android» становится особенно интересным. Потому что сама по себе общая кодовая база — еще не ценность. Можно сделать много общего кода и получить дорогое сопровождение, странные платформенные развилки и постоянное ощущение, что команда живет в компромиссе, который никому не приносит радости. А можно, наоборот, добиться такого баланса, при котором общий код реально снижает стоимость разработки, ускоряет выпуск функциональности и делает продукт устойчивее. Поэтому главный вопрос звучит не как «можно ли переиспользовать код», а как «в каких условиях это действительно окупается, а в каких превращается в красивую, но дорогую идею». Это не про процент совпадающих файлов, а про стоимость системы целиком.

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

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

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

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

Продакшен сразу ломает романтическую картину

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

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

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

Когда общий код действительно работает в пользу продукта

Есть целый класс приложений, для которых React Native выглядит особенно убедительно именно в продакшен-среде, а не в демо. Это продукты, где значительная часть ценности находится в потоке экранов, работе с данными, типовых пользовательских сценариях, формах, списках, карточках, авторизации, сетевом взаимодействии, личных кабинетах, каталогах, внутренних интерфейсах, медиа-лентах, контентной подаче, обычной навигации и довольно предсказуемом наборе мобильных паттернов. Там, где продукт в первую очередь строится вокруг бизнес-логики и повторяющихся экранных схем, общий код между iOS и Android часто начинает окупаться очень быстро.

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

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

Когда окупаемость начинается почти сразу

Быстрее всего общий код окупается там, где продуктовая команда живет частыми итерациями. Если новые экраны и новые сценарии появляются регулярно, если приходится быстро проверять гипотезы, если важна симметрия между iOS и Android, то единый слой на React Native начинает приносить очень понятную выгоду. Команда делает функцию один раз, обсуждает ее один раз, тестирует значительную часть общей логики один раз, а затем адаптирует то, что действительно требует платформенного различия.

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

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

Где общий код начинает врать о своей выгоде

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

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

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

Настоящая окупаемость — это не только меньше кода

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

React Native окупается особенно сильно там, где он снижает не число файлов, а число параллельных разговоров. Один компонентный слой, одна бизнес-логика, один набор сценариев, одна общая продуктовая дискуссия — всё это часто ценнее, чем сам факт технического совпадения кода. Когда iOS и Android перестают жить как два почти отдельных продукта, команда начинает быстрее принимать решения. Это трудно красиво показать на диаграмме, но именно здесь обычно и лежит главная организационная выгода.

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

Но без нативной зрелости всё равно не обойтись

Самая вредная реакция на разговор о React Native — услышать «общий код» и решить, что нативная разработка теперь не нужна вовсе. Одно из самых полезных отрезвлений последних месяцев состоит как раз в обратном: React Native нельзя честно продавать как способ полностью уйти от нативного кода. Эта иллюзия была слишком удобной на старте, но продакшен быстро ее разрушил. Почти любой серьезный продукт рано или поздно упирается в области, где нужен нативный код: интеграция с особыми возможностями платформы, работа со сторонними SDK, нестандартные интерфейсные элементы, производительные модули, тонкая настройка поведения приложения.

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

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

Общий код окупается только при инженерной дисциплине

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

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

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

Как понять заранее, что проекту React Native подходит

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

В-третьих, у команды должна быть сильная JavaScript-база и готовность не бояться мобильной специфики там, где она действительно нужна. React Native особенно хорош не для тех, кто хочет «избежать мобильной разработки», а для тех, кто хочет сделать ее более эффективной, сохранив часть уже накопленной культуры. Это очень важная разница. Избегать платформы бессмысленно. Договариваться с ней — полезно.

И, наконец, продуктовая организация компании должна уметь мыслить общими сценариями, а не двумя полностью разошедшимися мобильными ветками. React Native приносит максимальную пользу там, где сама структура принятия решений в компании готова к общей мобильной логике. Если же внутри организации iOS и Android исторически живут как почти независимые царства, выгода от общего кода может оказаться гораздо ниже, чем ожидалось.

Где экономия особенно заметна в долгую

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

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

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

Когда общий код не окупается, несмотря на внешнюю эффективность

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

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

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

Что можно честно сказать о React Native в проде

Уже видно главное: React Native — не игрушка, не мимолетный фокус и не просто удобный способ быстро собрать мобильное демо. Он действительно может работать в продакшене и действительно способен приносить реальную экономию за счет общего кода между iOS и Android. Но эта экономия не возникает автоматически и не покупается одной лишь верой в JavaScript. Она появляется только там, где проект по своей природе допускает значительный общий слой, а команда достаточно дисциплинирована, чтобы не превращать этот слой в свалку компромиссов.

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

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

Окупается не процент переиспользования, а сэкономленная продуктовая работа

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

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

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

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

Автор

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

Обновлено

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