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

⚡️ Простой live reload не только для Go

Eletrize это утилита для live reload, которая следит за файлами, пересобирает и перезапускает приложение при изменениях кода.

Идея возникла как замена Realize после того как команды автора столкнулись с проблемами установки и рандомными падениями этого тулза. В ответ он собрал Eletrize с упором на предсказуемый запуск, конфигурацию через отдельный файл и удобную интеграцию с VS Code launch конфигами.

Пример конфига:

schema:
  - label: API
    workdir: ""
    envs:
      key: "value"
    env_file: ".env"
    watcher:
      path: "."
      recursive: true
      excluded_paths:
        - "frontend"
      extensions:
        - ".go"
    commands:
      build:
        method: "go"
        args:
          - "build"
        envs:
          key: "value"
        env_file: ""
      run:
        - method: "./server"
          envs:
            PORT: "8080"
          env_file: ""

Если не хочется тянуть тяжелые dev окружения вроде Docker compose для каждого pet проекта, Eletrize выглядит как вариант легкого live reload поверх стандартного go build && ./app, который можно использовать и с другими языками.

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

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

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

#GoToProduction

⚡️ Зачем в 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

Конкурентность, которая не блокирует бюджет

В Go мы любим простоту и эффективность. Наша новогодняя акция работает так же: никаких сложных условий и скрытых аллокаций памяти.

Ты берешь 3 курса, а платишь за 1.

Оплата по самому дорогому курсу в наборе, два других — бесплатно.

Что усилит Go-разработчика:

— архитектуры и шаблоны проектирования (микросервисы сами себя не построят);

— алгоритмы и структуры данных.

Запустить горутину обучения

Таймаут контекста: 31 декабря.

Помощь с выбором: @manager_proglib

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

Есть задача с собеседования: нужно поделить два целых числа без операций деления, умножения и остатка. При этом результат должен поместиться в 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

👨‍💻 Самоподписанный 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

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

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

— GoLand 2025.3

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

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

Почитать:

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

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

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

#GoLive

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

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

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

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

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

#GoGiggle

⚙️ 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

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

Иногда одному объекту нужно сразу несколько ярлыков: можно читать, писать, удалять, но не админ. Хранить всё это в отдельный 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