💻 Не только commit и push

Напоминаем вам простые, но полезные команды для работы с git-репозиториями.

1. Отображение истории в виде графа:

git log --graph --oneline --all --decorate

2. Временное сохранение изменений без коммита:

git stash push -m "Описание стэша"
git stash list
git stash apply stash@{0}

3. Поиск по коммитам:

git log -S "поисковая строка"

4. Переименование последних коммитов в интерактивном режиме:

git rebase -i HEAD~3

Вспомнили все команды — ставьте 👍

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

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

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

👨‍💻 ИИ в разработке: страх и адаптация

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

Я только что наблюдал, как AI-агент взял задачу в Jira, разобрался в нашей кодовой базе и за несколько минут отправил Pull Request — и это меня действительно пугает.

💬 Что поменялось с тех пор? ИИ вас уже заменил?

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

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

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

🚀 Флаг -cpu: стресс-тесты на разном числе ядер

В начале года рассказывали про этот флаг — он до сих пор остаётся одним из самых недооценённых инструментов для тестирования конкурентного кода.

Флаг -cpu запускает тесты с разными значениями GOMAXPROCS. Указываете список — Go прогоняет тесты для каждого:

go test -cpu=1,2,4,8 -v

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

Зачем это нужно

Гонки данных и дедлоки часто проявляются только при определённом уровне параллелизма. На одном ядре всё работает, на восьми — падает. Флаг -cpu помогает поймать такие баги до продакшена.

Ещё это способ понять, как код масштабируется. Если на 8 ядрах работает не быстрее, чем на 2 — где-то узкое место.

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

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

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

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

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

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