😄 Как выглядят инструменты после новогодних

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#лучшее_из_библиотеки_2025

👋 Начинаем подборку лучших постов на 2026

Праздники закончились и с ними осталась подборка лучшего контента за 2025 год.

💬 Админ снова в строю, а вы? Рассказывайте чем занимались 👇

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

🛠 go fix для бенчмарков

Классический стиль бенчмарков в Go завязан на b.N, и из-за этого часто появляются b.ResetTimer и другая ручная обвязка.

Инструменты из экосистемы Go умеют автоматически применять замену, чтобы код был проще и меньше ошибался. Один go fix и всё красиво.

Пример:

// До
func Benchmark(b *testing.B) {
    s := make([]int, 1000)
    for i := range s {
        s[i] = i
    }
    b.ResetTimer()

    for range b.N {
        Calc(s)
    }
}

// После
func Benchmark(b *testing.B) {
    s := make([]int, 1000)
    for i := range s {
        s[i] = i
    }

    for b.Loop() {
        Calc(s)
    }
}

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoToProduction

💸 Код подешевел, а софт нет

Сейчас любой айтишник может вечером в терминале нагенерить себе рабочий тул, а на следующий день уже забыть как он устроен.

Автор статьи предлагает смотреть на происходящее как на взрыв персонального софта, который живет ровно столько, сколько живет задача.

Скрипт под конкретный DOM сайта, одноразовый парсер банкинга, утилита для своей рутины в проекте, все это стало дешево за счет LLM и CLI first подхода. И это нормально, потому что одноразовость там фича, а не баг. Инструмент сделал свое дело и может спокойно умереть.

Но как только нужен продукт, а не разовая вещь, вступают в игру знакомые расходы, поддержка, изменения окружения, UX, данные, надежность.​
И LLM тут не спасают, они не проектируют архитектуру и не несут ответственность за системные решения, этим по прежнему занимаются инженеры.

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoLive

✏️ Учим Go через практические задачи

Go Quests — это коллекция практических заданий для изучения Go. Репозиторий построен как серия квестов: вы решаете задачу, запускаете тесты и сразу видите, что работает, а что нет.

Каждый квест — отдельная папка с заготовкой кода и набором тестов. Вы дописываете логику, чтобы тесты стали зелёными. Никакой теории ради теории — только код и проверка результата.

➡️ Репозиторий

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoLive

🔼 Требования к Go-разработчикам растут быстрее, чем обновляются резюме. То, что вчера считалось сильным навыком, завтра становится необходимым опытом.

🗓 15 января в 20:00 МСК пройдет встреча с двумя экспертами, которые формируют требования к рынку: рекрутером Ксенией Маловой, знающей, почему 90% кандидатов отсеиваются ещё до техсобеса, и архитектором Александром Хохловым, который понимает, какие инженерные компетенции станут критичными для новых проектов.

❗️ Разберём тренды, требования и реальные ожидания компаний, поговорим о том, какие пробелы чаще всего мешают росту и как сформировать долгосрочную траекторию развития в Go-разработке.

▶️ Встречаемся в преддверие старта курса «Golang Developer. Professional», регистрация открыта: https://clc.to/cE064g

Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576, www.otus.ru

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoGiggle

🗑 Утечка тела ответа

Когда вы делаете HTTP-запрос в Go, клиент открывает соединение и выделяет буфер для тела ответа. Если не закрыть resp.Body, эти ресурсы остаются занятыми. Соединение висит в пуле, буфер держится в памяти.

Один забытый Close() — не проблема. Сто запросов в секунду без закрытия — уже катастрофа. Транспорт исчерпывает лимиты, новые соединения не открываются, запросы начинают таймаутиться.

Типичная ошибка:

resp, err := httpClient.Do(req)
if err != nil { 
    return err 
}
// читаем тело, возвращаем данные
// resp.Body.Close() отсутствует

Закрывайте resp.Body всегда. Даже если получили ошибку HTTP. Даже если статус не 200. Даже если не читаете тело ответа.

resp, err := httpClient.Do(req)
if err != nil { 
    return err 
}
defer resp.Body.Close()

// теперь читаете body или игнорируете

defer гарантирует, что соединение закроется при любом выходе из функции — через return, panic или нормальное завершение.

Добавьте линтер, который ловит незакрытые resp.Body. Например, bodyclose из golangci-lint. Он найдёт проблемные места автоматически.

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoDeep

🤨 Когда использовать sort.Sort, а когда sort.Stable

sort.Sort использует нестабильный алгоритм — работает быстрее, но не гарантирует сохранение порядка равных элементов.

sort.Stable использует стабильный алгоритм — медленнее, но сохраняет относительный порядок элементов с одинаковыми ключами.

Нестабильный пример:

package main

import (
    "fmt"
    "sort"
)

type Product struct {
    Name  string
    Price int
}

func main() {
    products := []Product{
        {"Laptop", 1000},
        {"Phone", 500},
        {"Tablet", 300},
        {"Monitor", 500},
    }

    // Сортируем только по цене
    sort.Slice(products, func(i, j int) bool {
        return products[i].Price < products[j].Price
    })

    fmt.Println("sort.Slice (нестабильная):")
    for _, p := range products {
        fmt.Printf("%s: $%d\n", p.Name, p.Price)
    }
}

Вывод (порядок Phone и Monitor может меняться):

Tablet: $300
Phone: $500
Monitor: $500
Laptop: $1000

Пример, когда стабильность важна:

package main

import (
    "fmt"
    "sort"
)

type Employee struct {
    Name       string
    Department string
    Salary     int
}

func main() {
    employees := []Employee{
        {"Alice", "Engineering", 80000},
        {"Bob", "Marketing", 70000},
        {"Charlie", "Engineering", 80000},
        {"Diana", "Marketing", 70000},
        {"Eve", "Engineering", 80000},
    }

    // Сначала сортируем по отделу (стабильно)
    sort.SliceStable(employees, func(i, j int) bool {
        return employees[i].Department < employees[j].Department
    })

    fmt.Println("После сортировки по отделу:")
    for _, e := range employees {
        fmt.Printf("%s (%s): $%d\n", e.Name, e.Department, e.Salary)
    }

    // Затем сортируем по зарплате (стабильно)
    // Порядок внутри одинаковых зарплат сохранится
    sort.SliceStable(employees, func(i, j int) bool {
        return employees[i].Salary < employees[j].Salary
    })

    fmt.Println("\nПосле сортировки по зарплате (стабильно):")
    for _, e := range employees {
        fmt.Printf("%s (%s): $%d\n", e.Name, e.Department, e.Salary)
    }
}

Вывод:

После сортировки по отделу:
Alice (Engineering): $80000
Charlie (Engineering): $80000
Eve (Engineering): $80000
Bob (Marketing): $70000
Diana (Marketing): $70000

После сортировки по зарплате (стабильно):
Bob (Marketing): $70000
Diana (Marketing): $70000
Alice (Engineering): $80000
Charlie (Engineering): $80000
Eve (Engineering): $80000

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoDeep

🏭 Трудоголизм — новая база

Эпоха офисных плюшек и корпоративных психологов закончилась быстрее, чем мы думали. Wellbeing-программы больше не окупаются, а на место одного выгоревшего сеньора приходит 200 резюме.

Компании решили, что выгорание — это не баг менеджмента, а побочный эффект, почему?

➡️ Читайте в статье

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

👨‍💻 Маленький слайс держит большой массив

Классическая ловушка памяти, которую многие не замечают.

buf := make([]byte, 10<<20)  // 10 MB буфер  
small := buf[:100]           // берём 100 байт  
store(small)                 // сохраняем  

Кажется, что small = 100 байт, но на самом деле он держит все 10 МБ.

Почему так происходит

Слайсы — это не копия данных, а три числа:

• Указатель на начало массива
• Длина (len) — сколько элементов видно
• Ёмкость (cap) — размер исходного массива

Когда делается buf[:100]:

• Создаётся новый slice
• Но он указывает на тот же самый базовый массив
• GC видит, что массив используется, и не удаляет его

Правильное решение:

// Вариант 1: явное копирование
smallCopy := make([]byte, 100)
copy(smallCopy, buf[:100])
store(smallCopy) // теперь 10 MB освободится

// Вариант 2: slices.Clone (Go 1.21+)
import "slices"
smallCopy := slices.Clone(buf[:100])

Не баг, а фича — просто нужно знать, как работают слайсы.

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoDeep

🔗 Криписсылки

CreepyLink.com — сервис для сокращения URL с твистом: генерирует самые страшные короткие ссылки.

Добавляет подозрительные домены типа cic.link, web-safe.link; суффиксы вроде _login.exe, root_4h3ku0_account_verificati..., .zip

Идеально для шуток, тестов антивирусов или «зловещих» приглашений

Вот ссылка на наш канал:

https://dropbox.c1ic.link/TODO_obfuscate_url_HiOGTC_update_info

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoGiggle

📞 Go для телефонии

sipgo — библиотека для работы с протоколом Session Initiation Protocol или SIP — основой VoIP, IP-телефонии и видеозвонков.

Если вы когда-то звонили через Skype, Zoom, WhatsApp или корпоративную АТС — где-то там был SIP.

Что умеет sipgo:

• Полная поддержка RFC 3261 (базовый SIP)
• Client & Server API
• Transaction layer (управление состоянием)
• Dialog management (звонки, сессии)
• RTP/RTCP support (передача аудио/видео)
🎯 User Agent, Proxy, B2BUA режимы

Быстрый пример SIP-сервера:

package main

import (
    "github.com/emiago/sipgo"
    "github.com/emiago/sipgo/sip"
)

func main() {
    ua, _ := sipgo.NewUA()
    
    srv, _ := sipgo.NewServer(ua)
    
    srv.OnInvite(func(req *sip.Request, tx sip.ServerTransaction) {
        // Входящий звонок
        res := sip.NewResponseFromRequest(req, 200, "OK", nil)
        tx.Respond(res)
    })
    
    srv.ListenAndServe("udp", "0.0.0.0:5060")
}

SIP-клиент совершает звонок:

ua, _ := sipgo.NewUA()
client, _ := sipgo.NewClient(ua)

// INVITE для звонка
req := sip.NewRequest(sip.INVITE, sip.Uri{
    User: "bob",
    Host: "sip.example.com",
})

tx, _ := client.TransactionRequest(req)

Архитектура:

Application
    ↓
Dialog Layer (звонки, сессии)
    ↓
Transaction Layer (надёжная доставка)
    ↓
Transport Layer (UDP/TCP/TLS)

Установка:

go get github.com/emiago/sipgo

Или репозиторий.

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoLive

🤩 Go 1.25.6 и 1.24.12

Это минорные релизы, но в них сразу шесть фиксов безопасности, так что обновление стоит запланировать как можно раньше.

• Первая проблема была в чтении ZIP архивов. Если открыть специально собранный архив, Go мог потратить слишком много времени на разбор имен файлов, из за чего сервис легко положить по CPU.

• Вторая проблема в обработке форм из HTTP запросов. При разборе URL encoded формы можно было заставить net/http выделить неожиданно много памяти, просто отправив огромное число параметров

Дальше правки в TLS. Там было два неприятных угла.

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

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

Еще две проблемы были в команде go.

• В одном случае можно было подсунуть такие флаги, что go запускал внешнюю утилиту pkg config с небезопасными аргументами, а теперь эти флаги чистятся до запуска.

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

• И последний фикс опять про TLS 1.3. В редком сценарии сообщения рукопожатия могли быть обработаны на неправильном уровне шифрования, что теоретически дает небольшой слив информации при атаке в локальной сети с возможностью подмешивать пакеты.

➡️ Анонс

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoLive

⚙️ fmt.Appendf вместо []byte

fmtappendf из набора modernize заменяет []byte(fmt.Sprintf(...)) на fmt.Appendf(nil, ...) чтобы убрать промежуточную строку.

// было
b := []byte(fmt.Sprintf("ID: %d", id))

// станет
b := fmt.Appendf(nil, "ID: %d", id)

Конструкция, где сначала собирается строка через fmt.Sprintf, а потом она конвертируется в []byte, переписывается в вызов fmt.Appendf с буфером nil. Если задача просто убрать лишнюю аллокацию строки в таких местах, проще доверить это автоматике и потом прогнать тесты и бенчи.

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoDeep

⚒️ Контрактный подход к API

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

Huma автоматически генерирует OpenAPI 3.1 JSON или YAML и включает в спецификацию все операции которые зарегистрированы в API.

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

Плюс есть удобные дефолты по путям публикации. можно отдать openapi файл, UI документации и схемы, не делая отдельный сервис под docs.

➡️ Попробовать Huma

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoToProduction

🐱 Переносим сайт на новый домен

Некоммерческая компания dotMeow запустила краудфандинг на создание нового домена верхнего уровня — и у них получилось. Если всё пойдёт по плану, то скоро мы увидим домен .meow.

Заявленная цена регистрации домена в зоне .meow — около €30 в год.

➡️ Сайт dotMeow

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoLive

📰 Первый дайджест 2026

Вот и прошла первая рабочая неделя нового года. Пора вспомнить что произошло за эти семь дней.

— Go 1.25.6 и 1.24.12

— Страшный сокращатель ссылок

— Трудоголизм — новая база

— Тело ответа утекло

— Свежий Cup o' Go

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoLive