Каждый год в середине лета мы с друзьями собираемся на E-CODE. Ещё относительно молодая конфа Ozon Tech стала уже своего рода легендой. Не удивительно: хардовость официальной части здесь не уступает громкости афтерпати.

На E-CODE 2026 нас по части бэкэнда ждут:

• Runtime Async с его + и –
• трассировка с eBPF
• ускорение на SIMD
• построение кастомной real-time системы видеоаналитики
• сравнительный анализ алгоритмов сборки мусора

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

Регистрируйтесь сейчас, чтобы услышать это всё вживую: https://ecode.ozon.tech/

12 и 13 сентября, Москва. До встречи на E-CODE!

https://github.com/inspektor-gadget/inspektor-gadget## Inspektor Gadget: eBPF для отладки Kubernetes и Linux

Inspektor Gadget — open-source набор инструментов для диагностики через eBPF.

Умеет:

- отслеживать процессы, файлы, сеть и syscalls;
- связывать kernel-события с pod и контейнерами;
- работать через kubectl gadget и CLI ig;
- запускать eBPF-гаджеты из OCI images;
- экспортировать данные в observability-системы.

Пример:

kubectl gadget run trace_open:latest

Покажет, какие файлы открывают процессы внутри кластера.

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

https://github.com/inspektor-gadget/inspektor-gadget

IRIS - open-source автодополнение на Go, которое рисует меню подсказок прямо внутри TTY.

Инструмент индексирует историю команд и aliases, после чего предлагает подходящие команды в реальном времени. Работает на Linux и macOS, включая SSH, Tmux и обычные виртуальные терминалы.

Внутри - один нативный Go-бинарник:

https://github.com/versenilvis/iris

Go-приём: как не получить 99% после округления

При независимом округлении процентов итоговая сумма может перестать быть равной 100.

33.3 → 33
33.3 → 33
33.4 → 33

Итого: 99%

Для простого интерфейса можно округлить первые значения, а последнему передать остаток:

package main

import "math"

func balancePercentages(values []float64) []int {
 if len(values) == 0 {
  return nil
 }

 result := make([]int, len(values))
 used := 0

 for i := 0; i < len(values)-1; i++ {
  result[i] = int(math.Round(values[i]))
  used += result[i]
 }

 result[len(values)-1] = 100 - used

 return result
}

Результат:

[]int{33, 33, 34}

Сумма останется равной 100.

Но это быстрый приём, а не универсальный алгоритм:

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

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

Код актуален для современной Go 1.26 и работает без изменений. Функция math.Round доступна начиная с Go 1.10.

⚡️ Одна из недооценённых сильных сторон Go - криптография в стандартной библиотеке.

Хороший пример - SHA-256.

Снаружи разработчик видит обычный crypto/sha256, но внутри Go умеет выбирать оптимальную реализацию под конкретный CPU.

На arm64 логика примерно такая:

if useSHA2 {
    blockSHA2(dig, p)
} else {
    blockGeneric(dig, p)
}

Если процессор поддерживает SHA-2 instructions - используется платформенно-оптимизированный код. Если нет - generic fallback.

В этом и сила стандартной библиотеки Go: простой API скрывает CPU feature detection, assembly и архитектурные оптимизации.

sha256.Sum256(data) выглядит простенько.

Но под капотом там очень серьёзная инженерия.

🐳 Docker полностью переписала слой виртуализации Docker Desktop

Новый Docker VMM вышел в public beta для macOS и Windows начиная с Docker Desktop 4.86. Раньше Desktop полагался на сторонний VMM, теперь Docker контролирует весь стек и может оптимизировать его именно под контейнерные нагрузки.

Что обещают на практике: более быстрый запуск контейнеров, заметно ускоренный file I/O между host и контейнером, возврат неиспользуемой RAM системе и более стабильную работу на Windows.

На Windows Docker отдельно заявляет сочетание изоляции уровня Hyper-V со скоростью, близкой к WSL2. Тот же движок уже используется в Docker Sandboxes, а дальше компания хочет построить единый runtime для ноутбуков, облака, on-prem и AI-агентов.

GA планируется на конец октября 2026 года, после чего Docker VMM должен стать движком по умолчанию для новых установок Docker Desktop на Mac, Windows и Linux.

https://www.docker.com/blog/docker-vmm-public-beta/

🧠 Алгоритм Флойда знают многие Go-разработчики: два указателя двигаются с разной скоростью и находят цикл в связном списке за `O(n)` времени и `O(1)` памяти.

Но есть менее известный алгоритм Брента, который решает ту же задачу и часто делает меньше переходов по Next.

Флойд:

slow := head
fast := head

for fast != nil && fast.Next != nil {
    slow = slow.Next
    fast = fast.Next.Next

    if slow == fast {
        return true
    }
}

Брент работает иначе: один указатель движется постоянно, а второй используется как контрольная точка. Размер интервала постепенно удваивается:

1 → 2 → 4 → 8 → 16

power, lam := 1, 1
tortoise := head
hare := head.Next

for hare != nil && tortoise != hare {
    if power == lam {
        tortoise = hare
        power *= 2
        lam = 0
    }

    hare = hare.Next
    lam++
}

Асимптотика та же:

O(n) по времени
O(1) по памяти

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

Флойда спрашивают на собеседованиях постоянно. Про Брента многие Go-разработчики вообще не слышали.

🐹 Go 1.27 ускоряет мелкие аллокации в куче почти в 2 раза — и для этого не нужно менять ни строчки кода.

На тесте с объектом размером 16 байт:

Go 1.26 → ~9,5 нс
Go 1.27 → ~5,5 нс

Причина в самом аллокаторе.

Раньше даже для маленьких объектов компилятор вызывал одну универсальную функцию, а runtime уже определял нужный size class: 8, 16, 24, 32 байта и т.д.

В Go 1.27 для объектов меньше 80 байт появились специализированные пути аллокации под конкретные классы размеров. Лишняя работа в runtime просто исчезает.

Больше всего выиграют программы, которые постоянно создают множество мелких объектов:

• парсеры
• деревья и списки
• очереди событий
• структуры с отдельной heap-аллокацией каждой ноды

А вот сервисы с редкими крупными аллокациями почти ничего не заметят.

Редкий случай, когда достаточно просто пересобрать проект новым Go и получить ускорение бесплатно.

https://vc.ru/dev/3081222-go-1-27-uluchshaet-proizvoditelnost-allokatsiy-pamyati

У SQLite один writer. И иногда это не ограничение, а очень удобная архитектура.

Работал с SQLite и увидел необычную схему: база работала сразу на нескольких машинах, но запись всё равно шла только через одну.

За это отвечал LiteFS.

Он не пытается превратить SQLite в полноценную distributed database. Вместо этого одна машина выбирается primary через distributed lease и получает право писать. Остальные работают как реплики.

Если primary пропадает, lease истекает и другой узел может занять его место.

В итоге сложная на первый взгляд задача сводится к довольно простой идее:

«Просто гарантируй, что в каждый момент времени пишет только одна машина».

А на скрине как раз часть Go-кода LiteFS, которая продлевает этот lease и следит, чтобы узел не продолжал считать себя primary после истечения TTL.

Julius от Praetorian - open source-инструмент, который по IP:Port или URL определяет, какой AI-сервис работает на endpoint.

Он умеет распознавать больше 60 платформ:

— Ollama
— vLLM
— SGLang
— LiteLLM
— llama.cpp
— Hugging Face TGI
— NVIDIA NIM
— Open WebUI
— Dify
— AWS Bedrock и другие.

Пример:

julius probe 192.168.1.100:8080

Julius отправляет специальные HTTP-probes, анализирует ответы и пытается определить конкретный сервис, а не просто понять, что endpoint совместим с OpenAI API. Он также может показать доступные модели.

Написан на Go, работает локально и собирается в один бинарник.

https://github.com/praetorian-inc/julius

Вам доклады по Go или Java? VK приглашает на митап с двойной начинкой
26 августа VK собирает Go- и Java-инженеров, чтобы прокачать знания.

В программе два трека — Go и Java, по три доклада в каждом.

Трек Go:
• «Компиляция Go в динамическую либу, или как мы ускорили выкатку фичи в два раза, но нам не понравилось», Михаил Кичигин, бэкенд-разработчик, Avito Tech
• «Go-платформа VK: как мы построили единую основу для создания Go-сервисов», Александр Апанасенко, руководитель команды SDK Backend, VK
• «Почтальон от Kubernetes до Palo Alto. Как осуществляется доставка информации об адресах», Дарья Кулькина, бэкенд-разработчик, Точка Банк

Трек Java:
• «Перформанс-трюки в поисковой платформе Ozon», Пётр Портнов, ведущий разработчик среднего поиска, Ozon
• «Архитектура современного движка платёжной системы и переход к новой архитектуре», Игорь Крикунов, технический лидер разработки DBC, Альфа-Банк
• «Переход от федерации S3-кластеров в пользу коммунального и мультитенантного кластера», Кирилл Боблак, ведущий разработчик One-cloud, VK

А ещё будет мастер-класс по прокачке навыка, который сделает вас звездой любого вечера, и афтепати, чтобы обсудить доклады в неформальной обстановке.

Встречаемся в 17:00, начало в 18:00. Участие бесплатное, регистрация обязательна.

Полный инженерный курс по AI-агентам на русском: от tool calling до production

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

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

https://github.com/justxor/Aiagentsfullcourse

10 GitHub-репозиториев, которые стоит сохранить Go-разработчику в 2026 году.

1. Golang Roadmap 2026 🇷🇺

Один из самых полных свежих roadmap на русском: 19 модулей от синтаксиса и concurrency до PostgreSQL, gRPC, Kubernetes, observability, distributed systems, eBPF, Wasm и AI-агентов. В каждом модуле есть практика и проекты.

github.com/Develp10/golangroadmap2026

2. Learn Go with Tests

Один из лучших способов реально выучить Go, а не просто читать синтаксис. Язык изучается через TDD: interfaces, concurrency, context, HTTP, generics, iterators, mocks и архитектура тестируемого кода.

github.com/quii/learn-go-with-tests

3. Practical Go

Свежие материалы Ardan Labs по практическому Go. Хороший переход от «я знаю синтаксис» к пониманию того, как писать нормальный production-код.

github.com/ardanlabs/practical-go

4. Go 101

Огромная и постоянно обновляемая база знаний по Go. Особенно полезна, когда базовый курс уже закончен и хочется глубже понять семантику языка, runtime, типы, memory model и неочевидное поведение Go.

github.com/go101/go101

5. Uber Go Style Guide

Как писать Go-код, который не стыдно отправлять на code review. Ошибки, goroutines, interfaces, naming, performance, functional options, table-driven tests и десятки production-практик. Репозиторий обновлялся и в 2026 году.

github.com/uber-go/guide

6. Go by Example

Go через маленькие работающие программы. Goroutines, channels, interfaces, HTTP, JSON, filesystem, timers, synchronization и другие вещи можно сразу запускать и менять руками. Проект продолжает учитывать новые возможности Go.

github.com/mmcgrana/gobyexample

7. Exercism Go Track

Если теорию уже прочитал - сюда за практикой. Большой набор задач с тестами и постепенно открывающимися концепциями Go. Track поддерживается и обновлялся в августе 2026 года.

github.com/exercism/go

8. LearnGo

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

github.com/inancgumus/learngo

9. Wild Workouts

Уже для тех, кто умеет писать Go, но хочет понять архитектуру больших приложений. На реальном проекте разбираются DDD, Clean Architecture, CQRS и рефакторинг.

github.com/ThreeDotsLabs/wild-workouts-go-ddd-example

10. Awesome Go

Не курс, а огромная карта современной Go-экосистемы: web, databases, distributed systems, observability, testing, networking, security, CLI и сотни библиотек. Репозиторий активно обслуживается и в 2026 году.

github.com/avelino/awesome-go

Если начинать с нуля, я бы шёл так:

Golang Roadmap 2026 → Learn Go with Tests → Exercism → Go 101 → Uber Guide → Wild Workouts.

🔥 diffyml - быстрый структурный diff для YAML и Kubernetes

Вместо обычного сравнения строк инструмент понимает структуру YAML и показывает реальные изменения в данных.

Что умеет:

- сравнивать Kubernetes-ресурсы по apiVersion + kind + name
- находить переименования ресурсов
- сравнивать директории
- подсвечивать изменения внутри строк
- работать как git external diff
- отдавать аннотации для GitHub, GitLab и Gitea CI
- маскировать чувствительные значения
- генерировать AI-summary изменений

Написан на Go и имеет всего одну внешнюю зависимость. На больших YAML-файлах авторы заявляют скорость до 1,5-1,9× выше ближайшего YAML-aware конкурента.

https://github.com/szhekpisov/diffyml

🔥 В Go есть странная, но полностью валидная конструкция:

error.Error(errors.ErrUnsupported)

Почему это работает:

- errors.ErrUnsupported — реальная ошибка из пакета errors
- error — интерфейс
- Error — его метод
- метод в Go можно вызвать как обычную функцию через method expression

Поэтому:

err := errors.New("oops")

err.Error()
error.Error(err)

дадут одинаковый результат.

А:

error.Error(errors.ErrUnsupported)

вернёт:

"unsupported operation"

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

Spinifex - open-source платформа с AWS-совместимым API для запуска инфраструктуры на собственном железе.

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

- EC2
- VPC
- S3
- EBS

Всё работает на bare metal и остаётся под полным контролем владельца инфраструктуры.

Spinifex рассчитан на сценарии, где обычное облако использовать нельзя или нежелательно:

- edge-площадки
- частные дата-центры
- среды с плохой связью
- изолированные и высокорисковые инфраструктуры

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

Проект написан на Go и открыт на GitHub:

https://github.com/mulgadc/spinifex

🔥 monty-go - безопасный запуск Python-кода от LLM прямо внутри Go

Проект оборачивает интерпретатор Pydantic Monty в WebAssembly и запускает его через wazero.

Что интересно:

- pure Go — без CGO
- без контейнеров и subprocess
- запуск sandbox меньше миллисекунды
- WASM-бинарник всего около 2,9 МБ
- можно ограничить память, время, число аллокаций и глубину рекурсии
- доступ к файлам и ОС идёт только через разрешённые Go-callbacks
- внешние функции работают через pause/resume

Главная идея — агент может написать один Python-скрипт, который вызывает ваши Go-инструменты, вместо длинной цепочки отдельных tool calls. Это уменьшает число обращений к модели и упрощает сложные agentic workflow.

MIT.

https://github.com/fugue-labs/monty-go