Содержание
Разбираем наиболее частые заблуждения о low-code подходе в разработке.
В прошлой статье о low-code в enterprise-решениях мы обращались к бизнесу. Однако на «Хабре» бóльшая часть пользователей — инженеры (Кэп!), и в комментариях к статье я увидел резонное количество типичных возражений по LCDP (low-code development platforms). И пока те, кто не знает про эффект Даннинга — Крюгера, уже ищут кнопку dislike, давайте разберем наиболее частые заблуждения и мысли.
На наш взгляд, наиболее частые заблуждения следующие.
Почему мы решили поднять тему low-code и перспектив развития IT-отрасли? По образованию я физик и предприниматель. В середине 90-х был собственником ISP (интернет-провайдера), после этого был в должностях от инженера в «Билайне» до управляющего партнера компании, специализирующейся на создании ПО по автоматизации (текущая должность, на которой я 7 лет). И сейчас интересно поразмышлять о том, что будет завтра".
Уровень абстракции кода растет. Начиная с машинных команд, уходя в процедурное программирование и отказываясь от управления памятью, с повышением количества фреймворков и развитием высокоуровневых языков, что будет завтра? Будет ли уровень абстракции разработки повышаться ещё, и если будет, то каким образом?
При этом, потребность в новых продуктах и автоматизации растёт. Дефицит специалистов в отрасли сейчас легко отследить на примере роста окладов: он опережает рост производительности труда в IT-сфере.
Кроме того, чем дольше одна команда разработки остаётся на проекте, тем глубже она погружается в операционное сопровождение проекта: большее количество фич порождает большее количество необходимых правок.
Расходы на разработку увеличиваются, и одновременно возникает конфликт интересов: бизнесу нужно меняться быстрее, а разработчики хотят интересных задач. Но бóльшая часть изменений у бизнеса — неинтересная.
На подобные вызовы IT-отрасль всегда отвечала повышением уровня абстракции и упрощением разработки. «Эпоху ассемблера» сменила «эпоха C++», затем наступила эпоха высокоуровневых языков с полным отсутствием управления памятью и ресурсами — и далее количество фреймворков и библиотек только увеличивалось.
Нет никаких предпосылок к изменению этого тренда. Давайте порассуждаем, сможет ли low-code продолжить его.
В Рунете каждая статья о low-code заканчивается комментариями о несовершенстве конкретного продукта (продуктов). Отдельно о продуктах поговорим чуть ниже, а для начала предлагаю подумать о концепции low-code в целом.
Разработчики поставляют заказчику конечную ценность. Вёрстка элементов, новые поля в сущностях, логика расчёта и потоки интеграции — всё это реализуется через программный код. Да, у него бывают какие-то настройки, которые иногда позволяют вносить изменения без привлечения разработчиков. Но на бо́льшую часть change requests всё-таки отвечают разработчики.
У разработчиков тут может возникать два желания.
В code-first реализовать эти желания сложно.
Представьте, что вы поставляете клиенту не непосредственно конечную ценность, а конструктор для реализации этой ценности. Нет, конечно, первичный функционал в вашем конструкторе придётся реализовать вам для целей отладки. Но при этом вы сможете создавать такие вызовы, функции и компоненты, которые...
Здесь важно отметить, что в code-first платформах тоже много настроек, и они даже разнесены по компонентам. Однако на практике их применение не позволяет снять с разработчика бо́льшую часть операционной работы.
Сталкиваясь с новым требованием, вы или собираете новый функционал в уже созданном конструкторе, или дописываете в нём активити и компоненты, если они отсутствуют.
Если посмотреть на low-code разработку глазами code-first разработчика, то меняется в первую очередь уровень абстракции компонентов. Кроме привычных сервисов, библиотек, конструкторов, есть ещё один, более высокий уровень абстракции — абстракция бизнес-логики.
Это справедливо и при использовании готовых LCDP, и при разработке в парадигме low-code.
В дискуссиях я раз за разом сталкиваюсь с тем, что под low-code понимаются просто очень гибкие системы. Например, «Битрикс» — потому что «в нём же есть бизнес-процессы и моделирование таблиц» — или WordPress.
LCDP — это такая платформа, в которой всё сделано на базе конструктора, ведь если это не так, рано или поздно поддержание такой платформы перейдёт в code-first.
Я бы обозначил следующие критерии LCDP.
Приведу излюбленные нами примеры.
Есть и пограничные случаи. Например, Pimcore, которая в части фронта, workflow, моделирования инфомоделей с калькулируемыми полями является по своей сути low-code (с некоторыми оговорками, но это не тема данной статьи). Если же пытаться делать что-то за рамками этого, вы свалитесь в традиционное поддержание монолита.
Или тот же «Битрикс». В нём удобно моделировать данные и строить бизнес-процессы, в которые при желании упаковывается PHP-код в low-code стиле (т. е. без длинных инициализаций). Однако огромный объём коробочного функционала, созданного не в LCDP-стиле, и отсутствие развитых инструментов low-code в других частях приводят к традиционному code-first.
Короче, если вы слышите, что «мы пробовали low-code платформу — и у нас ничего не получилось», советую разобраться в деталях. Может быть:
Это миф. Вы найдёте эти компоненты в подавляющем большинстве платформ. Многие (Mendix, Pega) имеют собственные CI с элементами low-code.
Хотя, безусловно, проводить ревью не всегда просто. Если с кодом компонентов всё понятно — там всё так же, как и в традиционном code-first, — то по поводу того, что можно сделать в конструкторе…
Представьте, вы разработали на Unity ходилку-стрелялку, поменяли стены, добавили горы, а потом сохранили и отправили всё это на ревью. Понятно, что версионировать изменение каждой стены вы не станете, и у вас будут огромные версии изменений, разобраться в которых в принципе будет достаточно сложно. Тем более когда дело касается визуальных изменений и вставок кода. Процесс ревью это осложняет в той мере, в какой увеличивается количество изменений за один коммит.
С переиспользуемостью тоже обычно всё в порядке: можно использовать процессы в качестве подпроцессов, можно из одной «джобы» вызывать другие и пр. Если есть желание сделать хорошо — с переиспользуемостью проблем не будет.
Разработчики обычно брезгливо относятся к самой идее того, что могут что-то накликать мышкой. Между тем подавляющее большинство задач разработчика — не rocket science, а рутина. Та самая, которой заниматься неинтересно и от которой хочется побыстрее избавиться.
В рамках проекта вы ограничены в выборе задач. Маловероятно, что к вам будут попадать исключительно интересные и креативные (это подразумевает, что кто-то другой займётся скучными задачами, и тогда всё вышесказанное применимо и к этому бедному человеку). Совсем не заниматься мелкими, а порой и однотипными, скучными вопросами почти невозможно. Просто потому, что кто-то ими должен заниматься.
Как ситуация поменяется в рамках LCDP? Скучные задачи никуда не денутся и будут возникать с той же частотой, но, вместо того чтобы тратить на них уйму часов, вы сможете закрывать их в разы быстрее или вообще передавать не разработчику. Зачем писать ещё одну интеграцию между системами, когда вы быстрее сделаете её через ETL-решения? Зачем забивать спринт созданием нового экрана, если это может накликать дизайнер?
Чем быстрее вы закрываете скучные задачи, тем больше времени у вас освобождается на более интересные. Более того, вы статистически чаще будете получать интересные задачи, потому что «перерыв» на рутину сократится в разы.
А что с реально талантливыми разработчиками, теми, кто любую самую сложную задачу делает изящно и быстро?
Сдав задачу в виде кода и получив через полгода change request, они сталкиваются со следующим:
Но очень редкая команда подписывается под рефакторинг. И редкий бизнес-пользователь поймёт, почему минорную правку ему оценили в несколько дней.
Что в итоге? Мы хотели писать интересный код, но через какое-то время ничего интересного не пишем. Нам остаются операционка и угрызения совести за то, что тут всё уже не очень красиво.
Если же вы мыслите в плоскости LCDP, дело не ограничивается только более быстрым решением рутинных задач. Рефакторинг происходит не на уровне конечных ценностей, а на более высоком уровне абстракции — на уровне реализации компонента конструктора. Как следствие, вам приходится больше думать и больше проектировать. Меньше областей остаются без вашего надзора, сделать плохо поддерживаемую задачу в LCDP намного сложнее ввиду того, что как минимум плохой нейминг или плохую логику могут обнаружить даже не разработчики. Сам подход заставляет вас больше мыслить абстракциями.
Лирическое отступление. Многие тимлиды конкретно для себя решают эту задачу так: реализацией занимаются другие члены команды, а они думают. Ни к чему хорошему это не приводит. Такие тимлиды часто начинают скучать по коду, а команда в целом становится более хрупкой. Антихрупкость таких людей обеспечивается за счёт хрупкости других членов команды, которые выступают в качестве машинисток. Этому пороку могут быть подвержены и традиционные, и low-code разработчики.
Можно не думать о будущем разработки, если допустить, что:
Давайте проведём мысленный эксперимент и прикинем, насколько всё это вероятно в реальной жизни.
Сейчас дефицит разработчиков в мире — около 10 %. Я не могу предсказать будущее, но могу представить, какие условия нужны, чтобы этот дефицит оставался всегда.
Первое: производительность разработчиков не должна повышаться настолько, чтобы она могла компенсировать разницу в дефиците (т. е. на 10 % относительно нынешней производительности).
Второе: количество разработчиков не должно расти быстрее, чем количество задач. Дополнительное условие — количество субститутов разработки не должно снижать этот дефицит.
А это противоречит фундаментальному закону спроса и предложения, ведь спрос всегда балансируется предложением до равновесного значения.
Что мы видим сейчас?
При 20 миллионах разработчиков в мире одна только Индия поставляет на рынок по миллиону разработчиков ежегодно (с ежегодным увеличением этого количества), т. е. существует некоторая вероятность, что в будущем дефицит разработчиков может не сохраниться. Есть и более радикальные суждения: у Германа Грефа, например, или у футуролога Герда Леонгарда.
Чем дороже разработка, тем больше разрыв между технологическими компаниями и всеми остальными. Те, остальные, вынуждены встраиваться в экосистемы гигантов. А экосистемы гигантов имеют очень высокую производительность труда (в силу объёмов). Это само по себе заставляет компании уходить в чужие экосистемы.
Было время, когда затраты на IT были несущественными. Но программное обеспечение становится всё более сложным и разнообразным, и стоимость ИТ-инфраструктуры является значимым фактором для стартапов и одной из основных статей бюджета. Чем дороже IT, тем больше субститутов для инвестиций.
Почему в IT сейчас много денег? Организации видят в цифровизации хорошо окупаемые инвестиции. Волна цифровизации пройдёт (все компании будут в какой-то степени диджитализированы, а прочие уйдут с рынка), нужно будет сопровождать и поддерживать применённые решения. При всё растущей стоимости IT не встанет ли вопрос о поиске иных источников заработка.
Не станет ли на каком-то этапе стоимость IT столь значимой, что будет автоматически отсекать бо́льшую часть новых — ныне рентабельных — проектов?
Я рекомендую разработчикам посмотреть в сторону low-code и как минимум выполнить несколько задач на любой из таких платформ — для расширения собственных границ.
Мы должны понимать область применимости, видеть срез текущих возможностей и изучать что-то новое, ведь на то мы и инженеры, чтобы смотреть на новые технологии глазами практиков. Возможно, вы не найдёте ни одной LCDP, которая решила бы ваши задачи, но как минимум исследовать этот тренд для развития инженерной эрудиции сегодня может быть полезно.
Ваша заявка отправлена успешно
Отправить снова
С вами свяжутся персональные менеджеры
Контакты
Назначить встречу
Забронировать время встречи с помощью Google Calendar