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

func get(s []int, i int) int { return s[i] }

Перед чтением s[i] компилятор внутренне добавляет сравнение индекса с len(s) и переход к panic, если индекс выходит за границы. Это две дополнительные инструкции при каждом вызове, которые нужны только для защиты от чтения за пределами слайса.

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

unsafe.Add(unsafe.Pointer(unsafe.SliceData(s)), i)

В этом случае компилятору больше не нужно выполнять сравнение, переход или сохранять ветку с panic. В итоге функция сводится буквально к нескольким ассемблерным инструкциям.

Это не значит, что теперь стоит повсюду использовать unsafe. По умолчанию компилятор защищает вас, но как только вы переходите к unsafe, эта защита исчезает. Одна ошибка — и вы получаете повреждение памяти.
Компиляторы — это всё-таки интересно, правда? Надеюсь, было полезно.

👉 @BackendPortal

Сегодня разработка ПО уже не ограничивается только классическим жизненным циклом SDLC. Инженерам всё чаще приходится работать сразу с двумя подходами: SDLC и ADLC.

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

ADLC относится уже к разработке ИИ-агентов. Здесь недостаточно просто написать код и развернуть приложение. Нужно определить цель агента, продумать его архитектуру, промпты и сценарии работы, подключить инструменты и память, настроить оценку качества, ограничения безопасности, мониторинг и наблюдаемость.

SDLC при этом никуда не исчезает. На нём по-прежнему строятся обычные программные продукты вроде GitHub, Stripe, Notion и Slack.

Но с появлением Devin, Claude Code, Manus, OpenAI Operator и других агентных систем ADLC становится отдельной важной частью разработки.

Поэтому современному инженеру всё полезнее понимать оба подхода: как создавать традиционное ПО и как проектировать надёжных, безопасных и предсказуемых ИИ-агентов.

👉 @BackendPortal

Наткнулся в интернете на интересную мысль:

Первое правило программирования - не делай хуже, чем есть сейчас.

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

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

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

Да, кодовая база может казаться старой и грязной. И да, возможно, её действительно стоит организовать по-другому. Но с той же вероятностью ты можешь ошибаться.

Тут важно смирение. Всегда помни, что ты знаешь меньше, чем думаешь, кем бы ни был. Мы склонны переоценивать своё понимание системы.

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

👉 @BackendPortal

При работе с JSONB знали ли вы, что следующие запросы функционально эквивалентны, но используют разные индексы?
Оба проверяют, что по пути user.city находится значение "Denver", но первый использует извлечение значения по пути и оператор сравнения, а второй — оператор вхождения.

B-tree индекс по выражению, использует операторы сравнения:

data->'user'->>'city' = 'Denver'

GIN-индекс, использует операторы вхождения:

data @> '{"user": {"city": "Denver"}}'

👉 @BackendPortal

Один из самых умных трюков для защиты данных, которые я видел в продакшене?

—> Временной RLS (Temporal RLS)

Row-Level Security — это функция PostgreSQL, позволяющая управлять тем, какие строки может видеть пользователь, прямо на уровне базы данных.

Вместо того чтобы фильтровать данные в коде приложения, RLS переносит контроль доступа в саму БД

Представь себе WHERE, который всегда включён — и индивидуален для каждого пользователя или роли.

Пример использования:

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

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

Как?

1. Включили RLS на таблице

2. Определили политику фильтрации строк

3. Включили принудительное применение RLS для всех обращений (необязательно, но рекомендуется)

Даже если кто-то подключится к базе напрямую через psql, BI-инструмент или SQL-клиент — он увидит только строки, старше 24 часов. Без исключений.

⏩Безопасность обеспечивается у источника

⏩Политики версионируются вместе со схемой

⏩Код приложения не участвует

Вывод:

RLS — это не только про фильтрацию арендаторов. С его помощью можно строить умные правила: задержка по времени, доступ по пользователям, мягкое удаление — и всё это реализуется самой БД

👉 @BackendPortal

CPU, GPU, TPU, NPU и LPU: в чём разница

Сегодня для AI-нагрузок используются пять основных аппаратных архитектур. Каждая по-своему балансирует между универсальностью, параллелизмом и доступом к памяти.

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

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

TPU ещё сильнее специализированы под AI. Их основа — массивы MAC-блоков, через которые веса, активации и промежуточные результаты передаются без постоянного обращения к памяти. Выполнением управляет компилятор, а сама архитектура изначально создавалась Google для нейросетевых задач.

NPU оптимизированы для энергоэффективного инференса на устройствах. Они используют MAC-массивы и встроенную SRAM, но работают с низкопотребляющей системной памятью вместо HBM. Такие процессоры устанавливают в смартфоны, ноутбуки, носимые устройства и IoT-системы. К этому типу относятся Apple Neural Engine и NPU от Intel.

LPU — архитектура Groq, созданная для обработки языковых моделей. Она исключает внешнюю память из критического пути: веса хранятся во встроенной SRAM, а выполнение полностью планируется компилятором. Это устраняет промахи кеша и накладные расходы на планирование во время работы.

Главный недостаток LPU — ограниченный объём памяти на одном чипе, поэтому для запуска крупной модели приходится объединять сотни процессоров. Однако это позволяет заметно снизить задержку.

Эволюция AI-железа движется от универсальных CPU к всё более специализированным архитектурам. На каждом этапе часть гибкости обменивается на производительность и энергоэффективность.

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

Та же проблема возникает и на программном уровне. Во время инференса LLM один GPU может ежедневно создавать терабайты KV-кеша, большая часть которого затем удаляется и пересчитывается. Это одна из причин высокой стоимости агентных нагрузок.


👉 @BackendPortal

Лето — неплохое время, чтобы навести порядок в базе данных. Например, проверить, не накопились ли в PostgreSQL бесполезные индексы.

pg_stat_user_indexes — системное представление PostgreSQL со статистикой использования индексов.

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

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

SELECT * FROM pg_stat_user_indexes;

Основные поля:
idx_scan — количество сканирований индекса с момента последнего сброса статистики. 0 означает, что индекс не использовался.
last_idx_scan — время последнего сканирования. NULL означает, что индекс ни разу не использовался после сброса статистики.
idx_tup_read — общее количество записей индекса, возвращённых при сканировании.
idx_tup_fetch — количество актуальных строк таблицы, реально полученных через индекс.

В первую очередь стоит обратить внимание на крупные индексы с idx_scan = 0: они создают нагрузку при записи, но не приносят пользы запросам.

Однако удалять их сразу не стоит. Если недавно выполнялся pg_stat_reset(), статистика может охватывать слишком короткий период. Лучше дождаться полного типичного цикла нагрузки.

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

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

Для безопасного удаления лучше использовать:

DROP INDEX CONCURRENTLY index_name;

Так PostgreSQL удалит индекс без блокировки таблицы через ACCESS EXCLUSIVE.

👉 @BackendPortal

PostgreSQL 19 сможет динамически подстраиваться под всплески нагрузки.

Вместо фиксированного пула I/O-воркеров, рассчитанного на условный «средний день», система будет масштабировать его по ситуации:

нагрузка растёт → очередь I/O увеличивается → PostgreSQL это замечает → запускает дополнительных воркеров → очередь разгружается → после снижения нагрузки лишние воркеры завершают работу.

Без ручного вмешательства и постоянного выделения ресурсов с запасом.

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

👉 @BackendPortal

Вышла новая статья о сборщике мусора Green Tea в Go.

Пейволл уже сняли, так что материал теперь можно прочитать бесплатно.

https://theconsensus.dev/p/2026/07/19/observing-gos-garbage-collector-old-and-new.html

👉 @BackendPortal

PostgreSQL 19 теперь умеет показывать активность асинхронного ввода-вывода прямо в EXPLAIN.

Это упрощает понимание:
→ где именно используется асинхронный I/O;
→ какие части плана обращаются к хранилищу;
→ получает ли запрос преимущество от асинхронного чтения.

Меньше догадок и больше прозрачности в том, что PostgreSQL делает под капотом плана выполнения запроса.
В PostgreSQL 18 появился асинхронный I/O.

А в PostgreSQL 19 стало проще увидеть, как он работает.

👉 @BackendPortal

Один из лучших инструментов для создания диаграмм в разработке — и при этом бесплатный и совместимый с GitHub.

Подходит для UML-диаграмм, блок-схем и описания процессов.

Готовые схемы можно экспортировать в изображения, PDF, HTML и другие форматы.

→ http://app.diagrams.net

👉 @BackendPortal

Postgres 19 исправляет AUTOVACUUM

Autovacuum удаляет мёртвые строки и поддерживает таблицы в нормальном состоянии. Теперь PostgreSQL умеет:

→ Запускать несколько autovacuum-воркеров
→ Оценивать таблицы по уровню риска
→ В первую очередь обрабатывать таблицы, которым очистка нужна срочно
→ Выполнять VACUUM для нескольких таблиц параллельно

👉 @BackendPortal

Morning Banger: новый выпуск PING от APNIC про загадочное поведение DNS-запросов.

Почти каждый DNS-запрос, который видят APNIC Labs, появляется дважды, а иногда и больше. В обычный день система фиксирует около 150 млн уникальных DNS-меток, но получает примерно 270 млн запросов.
Почему DNS постоянно повторяет одни и те же запросы?

В новом выпуске PING George Michaelson и главный научный сотрудник APNIC Geoff Huston разбирают, что происходит внутри DNS-инфраструктуры и почему дублирование запросов — это не просто лишний трафик, а часть поведения самой системы.

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

Интересный разбор того, как на самом деле работает один из фундаментальных слоёв интернета.
https://blog.apnic.net/2026/07/23/podcast-dns-query-duplication/

👉 @BackendPortal

Планировщик запросов PostgreSQL использует динамическое программирование, чтобы подобрать наиболее дешёвый порядок JOIN при объединении нескольких таблиц.

Пожалуй, один из тех редких моментов, когда dynamic programming встречается не в задачке с LeetCode, а внутри системы, которой разработчики пользуются каждый день.

https://internals-for-interns.com/posts/postgres-query-planner/

👉 @BackendPortal

Задержки это смерть от тысячи мелких порезов.

Так что чините. Начните с базы: один плохой запрос легко добавляет полсекунды, а на тысячах запросов это превращается в катастрофу. Не используйте SELECT *, добавляйте индексы, убивайте N+1 и всегда проверяйте запросы через EXPLAIN.

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

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

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

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

Скорость это не дополнительная фича, а фундамент нормального UX.

👉 @BackendPortal

Fleetbase — опенсорсная модульная ОС для логистики и управления цепочками поставок.

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

В общем, self-hosted логистика для тех, кому обычного CRUD уже недостаточно.

https://github.com/fleetbase/fleetbase

👉 @BackendPortal