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

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

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

🎮 Minecraft на чистом Go

Прошлой зимой показывали этот проект — полноценный клон Minecraft на Go и OpenGL. Без движков, всё с нуля: рендеринг, физика, генерация мира.

Запуск:

git clone https://github.com/GianlucaP106/minecraft && cd minecraft
go run .

Если хотите разобраться в 3D-графике без Unity и Unreal — исходники открыты.

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

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

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

📂 Пакет embed в Go: файлы внутри бинарника

С помощью директивы //go:embed вы можете встроить файлы (например, HTML, CSS, конфигурационные файлы или изображения) прямо в бинарный файл.

Как использовать:

//go:embed hello.txt
var hello string

//go:embed version.json
var version []byte

//go:embed templates/*
templates embed.FS

go build втянет файлы. string для текста, []byte для бинарей, embed.FS для папок.

Плюсы:

+ Один файл для деплоя
+ Файлы защищены от изменений
+ Нет зависимостей от FS окружения

Минусы:

- Большие файлы раздувают бинарник
- Динамические конфиги не подойдут

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

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

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

🌳 Бинарное дерево поиска (BST) в Go

BST — это бинарное дерево, где:

• Значение в левой ветви меньше значения в узле.

• Значение в правой ветви больше значения в узле.

Такое свойство обеспечивает эффективный поиск, вставку и удаление — в среднем за O(log n).

Пример реализации:

// Node — узел бинарного дерева
type Node struct {
    Value int
    Left  *Node
    Right *Node
}

// Insert — вставка нового значения в дерево
func (n *Node) Insert(value int) {
    if value < n.Value {
        if n.Left == nil {
            n.Left = &Node{Value: value}
        } else {
            n.Left.Insert(value)
        }
    } else if value > n.Value {
        if n.Right == nil {
            n.Right = &Node{Value: value}
        } else {
            n.Right.Insert(value)
        }
    }
}

// Search — поиск значения в дереве
func (n *Node) Search(value int) *Node {
    if n == nil {
        return nil
    }
    if n.Value == value {
        return n
    } else if value < n.Value {
        return n.Left.Search(value)
    } else {
        return n.Right.Search(value)
    }
}

// InOrderTraversal — обход дерева в порядке (LNR)
func (n *Node) InOrderTraversal() {
    if n == nil {
        return
    }
    n.Left.InOrderTraversal()
    fmt.Print(n.Value, " ")
    n.Right.InOrderTraversal()
}

Как это работает?

1️⃣ Вставка:

• Если значение меньше текущего узла, идём в левое поддерево.

• Если больше — в правое.

• Если узел пуст, создаём новый.

2️⃣ Поиск:

• Сравниваем искомое значение с текущим.

• Меньше — идём влево, больше — вправо, равное — нашли.

3️⃣ Обход:

• In-order обход (LNR) обходит узлы в отсортированном порядке.

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

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

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

🆚 ORM или чистый SQL

Помним, весной мы спрашивали у вас про подходы к базам в Go. Тогда народ активно спорил про ORM против ручных запросов. А что сейчас?

💬 На чем строите свои проекты сейчас? GORM, Ent, sqlx или чистый SQL? Делитесь в комментах, особенно если что-то поменялось за год

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

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

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

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

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

🐸 Библиотека 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-разработчика

#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