1207
По сотрудничеству пишите в личные сообщения канала.
😬 TOON: новый формат на смену JSON для более эффективного взаимодействия с LLM?
TOON — это ещё один способ записать те же самые JSON-данные, но компактнее и понятнее для моделей. Вместо "key": "value" он использует отступы как YAML и табличную запись для массивов объектов: шапка с названиями полей, дальше строки с данными.
Пример из README: вместо обычного JSON с пользователями — строка users[2]{id,name,role}: и две строки 1,Alice,admin и 2,Bob,user. Структура при этом не теряется: объекты, массивы и примитивы остаются теми же, формат — просто «другая запись» того же JSON.
Главная идея — экономия токенов и более предсказуемое поведение LLM на больших массивах данных. Помните, мы даже рассказывали про то, что от формата напрямую может зависеть результат генерации.
В бенчмарках TOON даёт порядка 30–60% экономии токенов на больших ровных массивах объектов по сравнению с форматированным JSON и заметно меньше, но всё равно ощутимо — против compact JSON. На ряде задач TOON показывает чуть более высокую точность ответов, чем обычный JSON при меньшем числе токенов.
При этом авторы честно фиксируют зоны, где TOON не выгоден.
Если структура сильно вложенная, неравномерная и почти не подходит под табличный вид, компактный JSON в тестах иногда оказывается короче. Если данные вообще чисто табличные и плоские, CSV по-прежнему даёт минимальный размер, а TOON добавляет небольшой оверхед ради явной структуры и валидации.
npx @toon-format/cli и TypeScript-библиотека @toon-format/toon.
💥 Google представил Green Tea GC — сборщик мусора, который экономит до 40% CPU
Новый сборщик мусора в Go – Green Tea GC – уже тестируют в продакшене Google, и результаты ошеломляют — до 40% меньше времени на сборку мусора.
Исследование провели инженеры Google — Michael Knyszek и Austin Clements. Их цель: адаптировать Go GC под современные многоядерные процессоры, где традиционные алгоритмы просто застревают в ожидании кэш-памяти. Green Tea дебютировал в Go 1.25 как эксперимент (через GOEXPERIMENT=greenteagc), и уже в Go 1.26 его планируют включить по умолчанию.
Главные инсайты:
🟣 Green Tea переходит от сканирования объектов к сканированию страниц памяти — это резко ускоряет обработку
🟣 В процессе сборки мусора теперь происходит меньше случайных обращений к памяти
🟣 В среднем — на 10% меньше CPU времени на GC, максимум — до 40% экономии
🟣 На новых CPU с AVX-512 ожидается ещё +10% ускорения благодаря векторным инструкциям
🟣 Уже к Go 1.26 это будет дефолтный GC (с возможностью откатить через GOEXPERIMENT=nogreenteagc)
Green Tea не появился из ниоткуда, он стал результатом многолетней командной работы. Идея родилась ещё в 2018-м, обрела форму в 2024-м, когда прототип писали в японских кафе за чашкой матча, и превратилась в продакшн-технологию в 2025-м (см. картинку). Это пример того, как одно простое инженерное озарение становится революцией, когда за ним стоит сообщество.
Источник
@go_for_devs
⚡️ 1 000 000 узлов в Kubernetes
Кажется, кто-то снова решил побить рекорды: проект k8s-1m замахнулся на кластер из миллиона узлов.
Если вкратце:
1. Команда проекта разделила данные по степени важности. Критически важная информация сохраняется надёжно, а временные данные — такие как сигналы активности узлов — обрабатываются в упрощённом режиме, без избыточных гарантий. Это позволило значительно повысить производительность при большом числе операций.
2. Сетевой уровень построен на IPv6, что устраняет необходимость в NAT и дополнительной маршрутизации. Вместо одного централизованного планировщика используется распределённая схема: несколько независимых компонентов обрабатывают свои части кластера и передают результаты агрегатору. Такой подход снижает нагрузку и ускоряет распределение задач между узлами.
3. Основное ограничение выявилось не в самом Kubernetes, а в используемом хранилище данных. Стандартный etcd оказался узким местом при высокой частоте обновлений. В проекте его заменили на более лёгкую in-memory реализацию, что позволило увеличить скорость обработки и снизить задержки.
Главный вывод — масштаб системы определяется не количеством узлов, а скоростью и эффективностью работы с данными. При росте инфраструктуры важно разграничивать типы нагрузок, оптимизировать хранение и использовать горизонтальное масштабирование вместо усложнения отдельных компонентов.
Полный обзор на Хабр
Инструкция по запуску
@go_for_devs
❓ Как структурировать маршруты в Gin
При разработке веб-API у вас часто бывает множество конечных точек, логически связанных между собой. Например, один набор маршрутов — для управления пользователями, другой — для работы с товарами, третий — для обработки заказов. Без должной организации ваш код быстро превращается в хаотичный набор маршрутов, который трудно читать, сопровождать и развивать.
r.GET("/books", getBooks)
r.POST("/books", createBook)
r.GET("/members", getMembers)
r.POST("/members", createMember)
package main
import (
"github.com/gin-gonic/gin"
)
func main() {
r := gin.Default()
// Grouping book-related routes
bookGroup := r.Group("/books")
{
bookGroup.GET("/", getBooks)
bookGroup.POST("/", createBook)
}
// Grouping member-related routes
memberGroup := r.Group("/members")
{
memberGroup.GET("/", getMembers)
memberGroup.POST("/", createMember)
}
r.Run()
}
/books, а все, связанные с читателями, — под /members. Это упрощает навигацию по коду и понимание его структуры.
🗑 Сборщик мусора в Go. Часть 3: Управление скоростью GC
Команда Go for Devs подготовила перевод статьи о том, как в Go устроено управление скоростью работы сборщика мусора.
TL;DR: даже при тысячах горутин GC подстраивается под нагрузку, выбирая между меньшим числом долгих пауз и большим числом коротких.
Итог — разработчику почти не нужно вручную «крутить» настройки, рантайм сам находит оптимальный ритм.
📚 Подробности на Хабр: https://habr.com/ru/articles/953426/
Первая статья из серии.
Вторая статья из серии.
🤨 Goiaba: Go-компилятор на Rust
Raph Amorim решил написать компилятор для Go… на Rust. Проект называется Goiaba (в переводе с португальского — гуава), и это пока эксперимент, но довольно показательный.
Автор известен по вкладам в экосистему WebAssembly и Wasmer. Его цель — исследовать, насколько реально собрать полноценный Go-компилятор с нуля на Rust, не используя LLVM, TinyGo или классический toolchain от Google.
• Goiaba написан на чистом Rust, без зависимостей от существующих Go-компиляторов.
• Потенциально может использоваться как библиотека внутри Rust-проектов.
• Может компилировать Go-код в WebAssembly, как TinyGo, но с иным подходом к архитектуре.
• Сообщество уже спорит, сможет ли он быть быстрее официального Go-компилятора (сомнительно, но Rust даёт шанс на более безопасные оптимизации).
На Hacker News обсуждение быстро скатилось в старую добрую войну “Rust vs Go”: кто быстрее компилирует.
> Скорость компиляции — не то, о чём я переживаю в Go. В отличие от Rust, с которым я почти не работаю — в том числе именно из-за скорости компиляции.
> Меня реально удивляет, что люди до сих пор жалуются на скорость компиляции Rust. Я работал с довольно большими проектами — отладочная сборка занимает несколько секунд, релизная — меньше минуты. Это точно не хуже, чем сборка TypeScript.
🐳 У Docker тоже есть свой агент — Gordon!
Кажется, многие пропустили, но релиз этого помощника состоялся уже какое-то время назад. Да, теперь и Docker не отстаёт от моды на ИИ — в Desktop и CLI появился собственный агент под именем Gordon. Отставить шуточки!
Gordon — это встроенный AI-ассистент, который умеет анализировать Dockerfile, искать ошибки, оптимизировать сборку, чинить контейнеры и даже мигрировать их на более безопасные Docker Hardened Images. Короче, если ваш контейнер внезапно “упал”, можно просто спросить:
docker ai "почему он упал?"
🔥 Пишем микросервисы на Go как в BigTech, с нуля
Как эффективно начать разработку микросервисов на Go с использованием современных инструментов, популярных в крупных технологических компаниях. Обсудили ключевые трудности при создании микросервисной архитектуры с нуля, такие как интеграция компонентов, межсервисное взаимодействие и поддержка системы.
Спикер представлил инструменты, которые могут значительно упростить этот процесс:
— gRPC для высокопроизводительного межсервисного взаимодействия;
— gRPC-Gateway для обеспечения совместимости с RESTful API;
— Buf для управления protobuf схемами;
— rk-boot для быстрого старта и стандартизации.
Леонид на практике показал, как эти технологии интегрируют в реальный проект, с акцентом на упрощение разработки и поддержания микросервисов.
В заключение — итоги и рекомендации, как начать внедрение этих инструментов в проекты.
😉 СМОТРЕТЬ НА YOUTUBE
🥳 Go исполнилось 16 лет: главное о развитии языка и экосистемы
10 ноября языку Go стукнуло 16 лет с момента выхода в Open source — и команда подошла к дню рождения не с ностальгией, а с результатами.
Вот главное, что произошло вокруг именинника за последнее время:
🟣 К одному из самых заметных прорывов относится новый сборщик мусора Green Tea, который снижает накладные расходы на 10–40%. Для продакшн-сервисов это означает меньше пауз, стабильнее задержки и ощутимый выигрыш без каких-либо доработок в коде. Подробнее про него мы писали тут.
🟣 Не менее значимый апдейт — flight recorder для диагностики: он сохраняет последние миллисекунды жизни сервиса и позволяет понять, что случилось, даже если проблема проявилась спустя часы. Подробнее про него мы писали тут.
🟣 А ещё Go уверенно заходит в эпоху ИИ: официальный MCP SDK и интеграции в gopls формируют прочный фундамент для разработки агентных систем и инструментов прямо на Go.
Команда обещает, что это только начало — и обороты они точно снижать не собираются.
@go_for_devs
💥 Как memory maps (mmap) обеспечивают в 25 раз более быстрый доступ к файлам в Go
Одно из самых медленных действий, которое можно совершить в приложении, — это системный вызов. Они медленные, потому что требуют перехода в ядро, а это дорогостоящая операция. Что делать, если нужно выполнять много операций ввода-вывода с диском, но при этом важна производительность? Один из вариантов — использовать memory maps.
Memory maps — это современный механизм Unix, позволяющий «включить» файл в виртуальную память. В контексте Unix «современный» означает появившийся где-то в 1980-х или позже. У вас есть файл с данными, вы вызываете mmap, и получаете указатель на участок памяти, где эти данные находятся. Теперь, вместо того чтобы делать seek и read, вы просто читаете по этому указателю, регулируя смещение, чтобы попасть в нужное место.
Производительность
Ниже сравнение производительности при чтении файла через memory map и через ReaderAt. ReaderAt использует системный вызов pread(), совмещающий seek и read, а mmap просто читает напрямую из памяти.
Случайное чтение (ReaderAt): 416.4 ns/op
Случайное чтение (mmap): 3.3 ns/op
---
Итерация (ReaderAt): 333.3 ns/op
Итерация (mmap): 1.3 ns/op
Запись через mmap, страницы не в памяти: 1870 ns/op
Запись через mmap, страницы в памяти: 79 ns/op
WriterAt: 303 ns/op
WriterAt, использующий системный вызов pwrite, даёт куда более предсказуемые результаты.
🫢 А вы знали, что у Go есть свой ML-фреймворк?
И называется он GoMLX, развивается с 2023 года — и, внимание, всё ещё жив! Последний коммит был пару недель назад.
GoMLX — это полноценный фреймворк на чистом Go, без Python и C++ под капотом. Он умеет всё, что должен уметь взрослый AI-инструмент: автодифф, готовые слои вроде LSTM и Attention, оптимизаторы (SGD, Adam), визуализацию, чекпоинты и даже метрики обучения.
За скорость отвечает OpenXLA/PJRT — тот же движок, что крутит JAX и TensorFlow. А если хочется поиграть — можно запустить модели прямо в браузере через WASM.
Разработчик уже показал демки: классификатор “кошки против собак”, diffusion-модель и даже AlphaZero-бот, который играет в настольную игру Hive. Всё это — на Go.
Конечно, GoMLX пока не собирается отбирать хлеб у PyTorch (будем честны, и не смог бы), но сам факт впечатляет: язык, который когда-то ассоциировался с микросервисами и горутинами, теперь присутствует и на территории машинного обучения.
GitHub
Туториал
Сравнение с Python
Попробовать
@go_for_devs
🪲 Cloudflare нашли редчайший баг — прямо в компиляторе Go для ARM64!
Да, это не опечатка: не рантайм, не race condition в их коде, а чистый косяк в сгенерированном машинном коде Go. И баг был настолько редким, что проявиться он мог только в инфраструктуре масштаба Cloudflare — при 84 миллионах HTTP-запросов в секунду.
На ARM64-машинах Cloudflare стали вылезать странные паники вроде traceback did not unwind completely — ошибка, указывающая на повреждённый стек при попытке раскрутки. Поначалу инженеры списали это на баг в старом коде с panic/recover, потом — на библиотеку Go Netlink. Но когда даже без неё паники продолжились, стало ясно: проблема глубже.
После недель отладки выяснилось: краш происходит при асинхронном вытестении (введённом в Go 1.14), когда рантайм прерывает горутину между двумя машинными инструкциями, корректирующими указатель стека. В этот момент стек оказывается в «разрезанном» состоянии — раскрутчик стека получает некорректный указатель и падает.
Инженеры написали минимальный Go-пример, где функция с большим стеком (>64 КБ) порождает тот самый двойной ADD. После пары минут работы программа стабильно умирала с SIGSEGV. Без сторонних библиотек. Только чистый Go.
package main
import (
"runtime"
)
//go:noinline
func big_stack(val int) int {
var big_buffer = make([]byte, 1 << 16)
sum := 0
// предотвращаем оптимизацию стека компилятором
for i := 0; i < (1<<16); i++ {
big_buffer[i] = byte(val)
}
for i := 0; i < (1<<16); i++ {
sum ^= int(big_buffer[i])
}
return sum
}
func main() {
go func() {
for {
runtime.GC()
}
}()
for {
_ = big_stack(1000)
}
}
Не, ну какие контрол-фрики эти правила придумывают
Может, еще пробелы по штангенциркулю подравнять?
👥 Группировка сабтестов в Go: от простого к сложному
Команда Go for Devs подготовила перевод статьи о том, как правильно группировать сабтесты в Go.
Автор показывает, что в большинстве случаев достаточно держать тесты плоскими, а когда нужна разная инициализация и очистка — добавить лишь один уровень вложенности.
В статье разбираются плюсы и минусы разных подходов: от ручных t.Run до reflection-хаков и сторонних библиотек.
📚 Подробности на Хабр: https://habr.com/ru/articles/953418/
⚡️ Насколько быстр Go? Симуляция миллионов частиц на смарт-ТВ
Команда Go for Devs подготовила перевод статьи о том, насколько быстрым может быть Go. Автор проверил это на практике — написал симуляцию миллионов частиц с мультиплеером, только на CPU и так, чтобы оно работало даже на смарт-ТВ.
Go оказался одновременно и разочарованием, и восторгом: он не дотягивает до Rust в вычислительных задачах, но удивляет своей простотой и тем, как легко масштабируется до сотен клиентов.
📚 Подробности на Хабр: https://habr.com/ru/articles/953434/
😋 Обедающие философы на Go: как не умереть от взаимной блокировки и голодания
В новой статье шаг за шагом решается классическая задача об обедающих философах на Go.
Вы узнаете, почему наивный подход ведёт к взаимной блокировке, как нарушить симметрию, чтобы избежать deadlock’а, и почему даже «рабочее» решение может оставить одного философа голодать вечно.
📚 Подробности на Хабр: https://habr.com/ru/articles/951224/