🛠 Используем deadcode для удаления неиспользуемых функций

В больших кодовых базах часто накапливаются функции, которые ни разу не вызываются — так называемый мёртвый код. Он усложняет поддержку: непонятно, можно ли смело удалять или менять такие функции.

Eсть утилита deadcode, которая помогает быстро находить и чистить неиспользуемые функции. Устанавливается она простой командой:

go install golang.org/x/tools/cmd/deadcode@latest

Для запуска сканирования проекта используйте:

deadcode .

Инструмент выведет список мёртвого кода с указанием файлов и строк:

internal/params.go:34:6: unreachable func: WithUserRanking
internal/wallets.go:50:35 unreachable func: Transaction.CollectionName
internal/utilx/randomx/string.go:23:6: unreachable func: RandomAlphabet

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

➡️ Документация

🔹 Алгоритмы и структуры данных
🔹 Получить консультацию менеджера
🔹 Сайт Академии 🔹 Сайт Proglib

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

#GoToProduction

👨‍💻 Контекстные ошибки в Go от джуна к сеньору

Модель ошибок в Go простая — функции возвращают error, и вызывающий решает, что с ним делать. Проблема в том, что голое «вернуть наверх как есть» редко подходит для живой системы.

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

Решение — добавлять уровень контекста в каждом слое с помощью fmt.Errorf("doing X for id=%s: %w", id, err). Так сохраняется исходная ошибка для errors.Is и errors.As и одновременно появляется понятное человеку сообщение.

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

Развёрнутый пример:

// Общая «смысловая» ошибка

var ErrTokenInvalid = errors.New("token invalid")

// Три разных места  где может что то пойти не так

func parseToken(raw string) (Token error) {
    const op = "parseToken"

    t err := reallyParse(raw)
    if err != nil {
        return Token{} fmt.Errorf("%s: parse raw token failed: %w" op ErrTokenInvalid)
    }

    return t nil
}

func validateClaims(t Token) error {
    const op = "validateClaims"

    if time.Now().After(t.ExpiresAt) {
        return fmt.Errorf("%s: token expired at %s: %w" op t.ExpiresAt ErrTokenInvalid)
    }

    if !t.HasScope("admin") {
        return fmt.Errorf("%s: missing admin scope: %w" op ErrTokenInvalid)
    }

    return nil
}

func lookupSession(ctx context.Context store SessionStore t Token) (*Session error) {
    const op = "lookupSession"

    s err := store.GetByID(ctx t.SessionID)
    if err != nil {
        if errors.Is(err sql.ErrNoRows) {
            return nil fmt.Errorf("%s: session %q not found: %w" op t.SessionID ErrTokenInvalid)
        }

        return nil fmt.Errorf("%s: load session %q failed: %w" op t.SessionID err)
    }

    return s nil
}

Можно спорить о синтаксисе и бойлерплейте, но без хороших сообщений и контекста ни один синтаксический сахар ситуацию не спасет.

🔹 Математика для Data Science
🔹 Получить консультацию менеджера
🔹 Сайт Академии 🔹 Сайт Proglib

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

#GoDeep

🤩 Локальный map store в файлах

MapStore — библиотека на Go для хранения данных в мапах прямо в файловой системе.

Поддерживает сменные кодеки сериализации, шифрование ключей через keyring ОС и полнотекстовый поиск по SQLite FTS5. Подходит для задач без внешних БД, где важна простота и локальность.

Каждый ключ сохраняется в отдельный файл с именем по UUIDv7, директории партиционированы для масштаба. Шифрование опциональное, использует системный keyring без лишних настроек.

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

🔹 Практический интенсив «Архитектуры и шаблоны проектирования»
🔹 Получить консультацию менеджера
🔹 Сайт Академии 🔹 Сайт Proglib

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

#GoDeep

Летим зимовать ✈️

Когда холодает, айтишники пакуют чемоданы, а мы разыгрываем ваучер на 50 000 рублей в Островке.

Поехать к морю или остаться среди снежных пейзажей — выбирайте сами!

Чтобы участвовать, нужно оставить любую реакцию под этим постом и подписаться на каналы ниже:

😎 Типичный программист
🐸 Библиотека программиста
🟢 Ostrovok! Tech

Теперь осталось нажать на кнопку участия под этим постом и вы в игре!

Итоги подведём 12 декабря. Победителя выберем с помощью бота. Подробнее с правилами можно ознакомиться здесь.

Всем удачи!

Участников: 111
Призовых мест: 1
Дата розыгрыша: 19:00, 12.12.2025 MSK (3 дня)

🧑‍🎓 Нужен ли диплом Go разработчику в 2025 году

Вокруг высшего образования в IT до сих пор много мифов. Одни уверяют что Go разработчику хватит пет проектов на GitHub другие советуют не выходить на рынок без корочек.

➡️ Узнаем реальность в статье

🔹 ML для старта в Data Science
🔹 Получить консультацию менеджера
🔹 Сайт Академии 🔹 Сайт Proglib

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

🎮 Ретроспектива игрового движка

Ebitengine в 2025 году показал что экосистема вокруг 2D игр на Go уже вышла из стадии эксперимента и живет как зрелый проект.

Автор движка Хадзимэ Хоси отмечает что спустя 12 лет разработки темп добавления новых фич снижается но количество вышедших игр в том числе на консолях только растет.

Экосистема вокруг движка активно живет за счет геймджемов. В июне прошел Ebitengine Game Jam 2025 двухнедельный онлайн джем где участники делали игры на скрытую тему и показывали возможности библиотеки.

➡️ Источник

🔹 AI-агенты для DS-специалистов
🔹 Получить консультацию менеджера
🔹 Сайт Академии 🔹 Сайт Proglib

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

#GoLive

🆚 Каналы против итераторов

Каналы в Go удобны для конвейеров и синхронизации, но как механизм итерации по коллекции они заметно проигрывают обычному «pull» подходу.

На больших объемах данных итерация через каналы примерно в два три раза медленнее прямого pull варианта и порождает больше аллокаций на элемент.

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

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

➡️ Посмотреть итоги бенчмарка

🔹 Математика для разработки AI-моделей
🔹 Получить консультацию менеджера
🔹 Сайт Академии 🔹 Сайт Proglib

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

#GoDeep

🔄 GoLand 2025.3

GoLand продолжает развиваться и в последних версиях получил заметный апгрейд по AI, производительности и интеграции с экосистемой.

Что нового

• JetBrains прокачали AI Assistant и объединили его с Junie в единую подписку, при этом базовые фичи вроде AI completion доступны бесплатно в IDE.

• Добавили инлайн промпты — можно просто написать запрос на английском прямо в коде и IDE преобразует его в изменения без лишних окон.

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

• Улучшили Kubernetes-интеграцию — появилось больше ресурсов в Services view и управление port forwarding прямо из IDE.

• Линтер Golangci-lint с поддержкой нового форматирования включен по умолчанию.

➡️ Источник

🔹 Специалист по ИИ
🔹 Получить консультацию менеджера
🔹 Сайт Академии 🔹 Сайт Proglib

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

#GoLive

👨‍💻 Куда утекает память

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

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

Вот такой простой код стал причиной утечки:

func leakyWorker(ctx context.Context, messages <-chan Message) {
 for {
  select {
  case message, ok := <-messages:
   if !ok {
    return
   }

   ctx = context.WithValue(ctx, "id", message.Id)
   processMessage(ctx, message)  
  case <-ctx.Done():
   return
  }
 }
}

➡️ Читать статью | Зеркало

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

#GoDeep

🔄 Релиз csv-go v3.3.0

Иногда релиз — это не «добавили пару фич», а признание: прежний подход был ошибкой. В csv-go v3.3.0 автор честно выкинул удобный, но прожорливый FieldWriter и заменил его на новый RecordWriter.

Что нового в csv-go

• В csv.Writer добавились функции NewRecord и MustNewRecord, которые возвращают RecordWriter и позволяют собирать строку как fluent‑цепочку прямо во внутренних буферах writer’а, без лишних слайсов и временных структур.

• Предыдущий подход с FieldWriter оказался дорог по памяти и приводил к escape’ам из‑за того, как Go анализирует вариадики и слайсы, поэтому API перепроектировали

csv-go остаётся без внешних зависимостей, использует «обычные» подходы без магии и при этом быстрее стандартной encoding/csv.

➡️ Changelog

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

#GoLive

💡 Побитовые права

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

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

Пример с правами доступа

Возьмём тип прав пользователя:

type Permission uint8

const (
  PermRead Permission = 1 << iota // 0000_0001
  PermWrite                       // 0000_0010
  PermDelete                      // 0000_0100
  PermAdmin                       // 0000_1000
)

Здесь каждое значение — это отдельный бит. Благодаря этому можно собрать набор прав в одну переменную:

var perms Permission

// Добавляем права
perms = PermRead | PermWrite   // 0000_0011
perms = perms | PermDelete     // 0000_0111
perms = perms &^ PermWrite     // убрали запись: 0000_0101

Проверка флага выглядит так:

func Has(perms, flag Permission) bool {
  return perms&flag != 0
}

if Has(perms, PermDelete) {
  // можно удалять
}

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

Составные флаги

Можно заранее определить группы флагов. Например:

const (
  PermReadWrite Permission = PermRead | PermWrite
  PermAll       Permission = PermRead | PermWrite | PermDelete | PermAdmin
)

Теперь можно быстро выдать все базовые права:

userPerms := PermReadWrite
adminPerms := PermAll

Если же у значения должен быть только один вариант, например, статус New/InProgress/Done, обычный enum с iota проще и понятнее, чем флаговый.

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

#GoToProduction

⚙️ Wails: десктоп на Go и веб-технологиях

Wails позволяет создавать кросс-платформенные десктопные приложения, сочетая Go для бэкенда и знакомые веб-фреймворки для фронтенда. Это альтернатива Electron, но легче и быстрее, без лишних зависимостей вроде CGO на Windows.

Как начать проект

Установка простая: go install github.com/wailsapp/wails/v2/cmd/wails@latest. Затем wails init -n myapp -t svelte для шаблона на Svelte.

Команда генерирует структуру с Go-кодом и фронтендом на Vite для быстрой разработки. Запуск wails dev включает живую перезагрузку и автогенерацию JS-биндингов для Go-методов.

Ключевые возможности

• Нативные элементы: меню, диалоги, прозрачность, темы.

• Биндинг Go в JS: передача структур, массивов без ручного сериализации.

• CLI для билда и пакета: wails build для exe, dmg, deb.

• Шаблоны для JS/TS: Svelte, React и другие, плюс runtime-библиотека.

Быстрее Electron, нативнее Tauri в плане UI. Сообщество растёт, документация с туториалами покрывает основы. Начните с hello world, и через час у вас рабочий прототип.

➡️ Написать своё фулстек приложение

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

#GoToProduction

✏️ Прикол выходного дня

На просторах GitHub появился репозиторий, где можно сгенерировать себе страницу с ошибками, которую шлёт Cloudflare, когда становится недоступным.

Это не просто скрин, а полноценная статическая страница, которую можно встроить в своё веб-приложение.

➡️ Сгенерировать свою ошибку

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

#GoGiggle

📰 Дайджест недели

Сегодня не будем вспоминать сколько осталось до Нового Года, а просто вспомним что произошло за неделю.

— GoLand 2025.3

— Ebitengine подвели итоги

— Релиз csv-go v3.3.0

Почитать:

— Нужен ли диплом Go разработчику в 2025 году

— Куда утекает память

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

#GoLive

👨‍💻 Самоподписанный HTTPS для Go за пару минут

Репозиторий https-cert-go решает приземленную задачу получить сертификат для локальной разработки без плясок с OpenSSL и длинными командами.

Пример:

import https "github.com/romance-dev/https-cert-go"

pub, priv, _ := https.GenerateKeys(https.GenerateOptions{Host: "proglib.io"})

Самоподписанные сертификаты обычно используют для локальных UI сервисов и внутренних API которые не торчат в интернет.

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

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

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

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

#GoToProduction

✏️ Делим без деления

Есть задача с собеседования: нужно поделить два целых числа без операций деления, умножения и остатка. При этом результат должен поместиться в 32 битный int. На практике это проверка на умение работать с битами и помнить про переполнения (или ещё одна причина вспомнить побитовые операции и забыть до следующего собеса).

Разложим как на доске:

• Есть dividend и divisor нужно вернуть целую часть деления с усечением к нулю. Делитель не равен нулю вычисления в диапазоне от минус два в тридцать первой до два в тридцать первой минус один.

• Можно в лоб вычитать divisor из dividend пока остаток не стал меньше делителя и считать шаги но это пролёт по времени и не работает на больших входах.

Главная идея — не вычитать делитель по одному разу, а вычитать сразу большие куски вида divisor умноженный на степень двойки. В двоичном мире умножение на степень двойки — это просто сдвиг влево, поэтому divisor << k не нарушает запрет на оператор умножения.

Алгоритм выглядит так:

1. Сначала обрабатываем спец случай, когда делимое равно минимальному int, а делитель равен минус один. В этом случае ответ теоретически равен 231231 и не помещается в int, поэтому по условию возвращаем максимальный int.

​2. Далее определяем знак результата через сравнение знаков делимого и делителя, сами значения приводим к модулю и переводим в int64, чтобы безопасно сдвигать и вычитать.

​3. Затем имитируем двоичное деление. Идём по битам от 31 до 0 и, если текущий делитель, сдвинутый на этот бит, все еще не больше остатка делимого, вычитаем его и прибавляем к ответу соответствующую степень двойки.

​4. В конце возвращаем результат с правильным знаком и проверяем, что он все еще внутри диапазона 32 битного int.

Код:

func divide(dividend int, divisor int) int {
const (
intMax = 1<<31 - 1
intMin = -1 << 31
)

// Спец случай переполнения
if dividend == intMin && divisor == -1 {
return intMax
}

// Определяем знак результата
neg := (dividend < 0) != (divisor < 0)

// Работаем с модулями в int64
a := int64(dividend)
b := int64(divisor)
if a < 0 {
a = -a
}
if b < 0 {
b = -b
}

var res int64

// Долгое деление в двоичном виде
for bit := 31; bit >= 0; bit-- {
if (b<<bit) <= a {
a -= b << bit
res += 1 << bit
}
}

if neg {
res = -res
}

if res > int64(intMax) {
return intMax
}
if res < int64(intMin) {
return intMin
}

return int(res)
}

По времени мы тратим O(log n), а по памяти константу, ведь всё делается на месте.
​
📍 Навигация: Вакансии • Задачи • Собесы

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

#ReadySetGo

⚡️ Зачем в Go errors.Is и errors.As

До Go 1.13 ошибок касались двумя инструментами: сравнение err == someErr и type assertion через err.(MyErrorType). Это работало пока ошибки были плоскими значениями, но сломалось в тот момент, когда в язык завезли нормальное оборачивание ошибок с контекстом.

Проблема с err == someErr в том, что оно сравнивает конкретное значение, а не суть ошибки. Как только начали делать fmt.Errorf("connect db: %w", err) или свои обертки с Unwrap, верхний err уже не равен исходному значению, несмотря на то, что логически это та же ошибка.

Нужен был стандартный способ раскрыть цепочку оберток и проверить лежит ли внутри нужная ошибка. Именно это делает errors.Is — проходится по цепочке через Unwrap и сравнивает каждое звено, пока не найдет нужный err или не упрется в nil.

Аналогичная история с типами. До Go 1.13 приходилось делать каскады type assertion или ручным образом проходить по цепочке unwrap’ов чтобы найти конкретный тип ошибки. errors.As формализует этот паттерн — он проходит по цепочке ошибок и пытается привести каждую к нужному типу, а при успехе заполняет ваш target.

Простым языком errors.Is — это сравнение с константной ошибкой, а errors.As — это типовая проверка с учетом оберток.

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

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

#GoDeep