Битрикс Stack
9 subscribers
11 photos
Download Telegram
Сюда буду собирать самое важное из Битрикс. Без рекламы и инфоцыганщины
Готовлю первый разбор. Подписывайтесь — выйдет на этой неделе
Здравствуйте. Подписывайтесь, скоро первые материалы
За 15 лет с Linux я понял одну неприятную вещь: **часть настроек нужна была не системе, а моему ощущению контроля**.

Когда-то я тоже жил по схеме: i3, polybar, тонкая настройка `vimrc`, скрипты на каждый чих, автопереключение всего при подключении монитора. Это выглядит как инженерная дисциплина, но часто превращается в отдельный проект по обслуживанию рабочего места.

Сейчас у меня Fedora почти без кастомизации: GNOME, браузер, редактор, видео для демо — и всё работает. Не идеально в эстетическом смысле, зато предсказуемо.

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

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

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

Схема простая:
`вопрос` → `ответ модели` → `ответ на ответ` → `усиление внутренней логики` → потеря внешней привязки.

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

Вывод практический: LLM нужна не свобода, а _границы, проверка и внешний якорь_. Иначе вместо архитектуры получаем самореференсный шум.
В начале июня я снова увидел старую картину: массово начали сбоить не только самодельные обходы, но и решения на связке `xray + VLESS + REALITY`.

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

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

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

Если у вас в проекте завязано что-то критичное на нестандартных каналах связи, держите план Б. И да, проверяйте не только «работает/не работает», а __почему__ именно отвалилось. Это экономит часы на бесполезной переборке конфигов.


Чтобы быть в курсе рынка — подпишись на @affcareers_spb
В проектах я часто вижу одну и ту же ошибку: люди недооценивают то, что «и у нас под боком не страшно». С живой природой это работает плохо.

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

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

С природой, как и с интеграциями, лучше работает сухой подход: __сначала понять, потом трогать__.
Типовой кейс из проекта: приходит запрос «сделайте так, чтобы Telegram просто работал, а не объясняйте мне, что такое Zapret и TgWsProxy». И вот тут любая ручная схема быстро превращается в батники, конфиги, консоль и звонки в поддержку.

Показали GUI-обёртку, которая закрывает эту боль почти полностью: она сама ставит нужные компоненты, подхватывает настройки, следит за состоянием и обновляется без участия пользователя. По сути, это попытка собрать `one click`-эксплуатацию там, где обычно живёт набор костылей.

С архитектурной точки зрения мне нравится не сам GUI, а идея убрать человека из цепочки регулярного обслуживания. Для инфраструктурных утилит это часто важнее красивой панели. И да, даже ритм-игра там есть — видимо, чтобы обновления проходили веселее 🙂
Иногда лучший способ «сделать асинхронно» — не городить два режима, а честно сломать совместимость и переписать всё под один контракт. В проектах на Битриксе я такую логику вижу регулярно: сначала добавляют второй путь «на всякий случай», потом растёт матрица тестов, усложняется поддержка, а выигрыш в производительности съедается зоопарком исключений.

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

Схема простая:
инициатор → единый обработчик → очередь/фоновая задача → запись результата → уведомление.

Мой вывод сухой, но практический: если архитектура уже расползается на «старый» и «новый» режимы, почти всегда стоит сначала считать не throughput, а стоимость поддержки. В enterprise это часто важнее. ⚙️
В проектах с 1C-Битрикс я регулярно вижу один и тот же паттерн: систему пытаются «закрыть» не логикой, а набором жёстких правил. Права, статусы, кодовые поля, ручные согласования — и всё это должно работать без права на ошибку.

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

В Битриксе так же живут многие интеграции:
схема одна, а нагрузка и точки отказа — в деталях.
Если не продумать кеш, права доступа и сценарии обновления, «суровая» система внезапно начинает тормозить, дублировать данные и ломаться на пустяках.

Из практики: самые живучие решения — не самые красивые, а те, где заранее описаны исключения. Архитектура без этого быстро превращается в кодовый замок, к которому потеряли инструкцию 🔧
Типовой кейс из проекта: на Android-устройстве в enterprise-сценарии «просто сто́р» внезапно начинает жить собственной жизнью — фоновые установки, телеметрия, постоянные запросы к системным данным. В коде это обычно выглядит как набор привычных для интегратора паттернов: сервисы, AIDL, локальная SQLite, пуш-команды, JNI-обвязка и отдельный слой мониторинга.

Для разработчика Битрикс здесь важен не сам скандал, а схема риска: любое приложение с широкими правами на устройстве становится точкой сбора данных и потенциальным каналом доставки кода. Если у вас корпоративный контур, MDM, VPN, SSO и мобильные клиенты 1C-Bitrix, надо смотреть не только на API, но и на то, что стоит рядом в ОС.

Антиошибка недели: считать, что «официально предустановлено» значит «контролируемо». В мобильной архитектуре доверие не даётся по умолчанию — его проверяют ревизией прав, сетевых вызовов и фоновых сервисов. 🔍
30 минут против месяца — это не про скорость, а про цену процесса.

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

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

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

И да, идеальные процессы тоже могут тормозить. Но отсутствие процессов почти всегда тормозит сильнее.
Я всё чаще ловлю одну и ту же мысль: в вебе много контента, но мало механики.

В истории с SEBERD IT Base мне зацепил не сам факт «ещё одного сайта про ИБ», а подход. Не очередной набор лозунгов про угрозы, а разбор того, как атака устроена внутри: по шагам, по протоколам, по логике действий.

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

Отдельно нормально смотрится решение с главной страницей. Не маркетинговая витрина, а живая лента с RSS/API. Без ручного парсинга HTML, без лишней магии — обычная интеграционная дисциплина: тянем структурированные источники, собираем, показываем.

Для меня это хороший пример того, как сайт перестаёт быть «страницей» и становится системой. Именно там обычно и начинается интересная архитектура.
В проектах я часто смотрю на QR-коды как на чисто утилитарный артефакт: ссылка, токен, оплата, и хватит. Но бывают решения, где сама форма уже часть коммуникации. NoiR Code — как раз из таких.

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

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

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

Поэтому гибридный формат обучения — рабочая схема, а не компромисс. У нас это выглядит так: базовые материалы уходят в СДО, сложные вопросы разбираются на консультациях, а затем знания сразу проверяются на реальном проекте. Без отрыва от задач, без паузы в SLA, без иллюзии, что всё запомнится с первого просмотра.

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

Собственно, типовой кейс из проекта: сначала обучение, потом внедрение, потом уже нормальная эксплуатация. Именно такой порядок обычно экономит и время, и бюджет. ⚙️
Хороший код не спасает, если архитектура уже поплыла.

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

Типовой кейс из проекта: форму делали быстро, потом к ней добавили CRM, уведомления, проверку прав, кеш, ещё одну валидацию, потом «маленькое» поле для маркетинга. В итоге один submit тянет за собой полсистемы. И вот уже не код плохой — плоха схема, по которой он собран.

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

Хорошая архитектура — это когда файл можно открыть через три года и понять не только «что здесь написано», но и «почему именно так собрано». 🧩
У «Почты России» теперь свой MVNO — «Почта России Мобайл». Пилот уже пошёл в Тверской и Калининградской областях, а также в Якутии. Сеть обеспечивает Билайн, тарифы — от 100 до 300 рублей.

Я такие запуски обычно читаю не как новость про связь, а как про архитектуру распределённой инфраструктуры. Смысл у MVNO простой: бренд и биллинг — у заказчика, радиосеть и часть операционных рисков — у партнёра.

Схема здесь знакомая:

бизнес-контур → свои тарифы и ЛК
оператор-партнёр → транспорт и покрытие
интеграции → активация, SIM/eSIM, баланс, поддержка

Для крупных экосистем это логичный ход: можно привязать связь к доставке, уведомлениям, сервисным кабинетам и CRM. Но на практике всё упирается в интеграции, а не в пресс-релиз: кто держит NPS, как стыкуются биллинг и поддержка, где ломается верификация, и кто отвечает за SLA 📎

Типовой кейс из проекта один и тот же: на бумаге сервис «свой», а по факту критические процессы завязаны на внешнего провайдера. И чем сложнее продукт, тем важнее заранее считать права доступа, обмен данными и точки отказа.
Два часа ночи. Релиз горит. Разработчик уже подключил ваш API, получил в ответ голое `invalid_request` и дальше начинает не интеграцию, а археологию: что сломалось, где именно, что ожидалось.

Я в таких кейсах всегда смотрю не на код ошибки, а на то, сколько работы вы переложили на человека.

Нормальная ошибка в API — это не «что-то пошло не так», а структура:
- что не так;
- в каком поле;
- какое значение ждём;
- как исправить;
- можно ли повторить запрос.

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

Схема простая:
`error_code` → стабильный код
`message` → коротко и по делу
`details` → список полей/причин
`request_id` → чтобы искать в логах
`hint` → что попробовать дальше

И да, «предсказуемый» API — это комплимент. Скучный API интегрируется быстро, не ломается внезапно и не заставляет писать в поддержку в три часа ночи. А время до первого успешного вызова я бы вообще ставил в KPI онбординга.