Просмотрщик сборок и исходного кода Go

Установка производится с помощью обычных команд Go:
go install loov.dev/lensm@main

Для Linux может потребоваться добавление некоторых дополнительных зависимостей. Чтобы не собирать версию Wayland или X11, можно использовать go install --tags nowayland loov.dev/lensm@main или go install --tags nox11 loov.dev/lensm@main соответственно.

Для запуска программы задайте фильтр регулярных выражений для проверяемой функции. -watch позволяет автоматически перезагружать исполняемый файл и информацию при его изменении.
lensm -watch -filter Fibonacci lensm

https://github.com/loov/lensm

👉 @golang_lib

💔 Ваша backend-разработка уже не та?

😔 Микросервисы плохо масштабируются, API перегружены, а REST уже не справляется?

🚀 Решение есть – gRPC! Быстрое и эффективное взаимодействие сервисов без лишних накладных расходов.

Как освоить? 18 марта в 20:00 на открытом вебинаре разберем gRPC, Protocol Buffers, совместимость API и создание серверов.

➡️ Запишитесь сейчас и 🎁 получите скидку на большое обучение «Golang Developer. Professional»: https://vk.cc/cJGVFr

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

Планировщик Go — самый подробный гайд простым языком

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

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

https://habr.com/ru/articles/891426/

👉 @golang_lib

Gotify/server

Простой сервер для отправки и получения сообщений в реальном времени по WebSocket. (Включает элегантный web-ui)

Нам нужен был простой сервер для отправки и получения сообщений (в реальном времени по WebSocket). Для этого существовало не так много проектов с открытым исходным кодом, а большинство существующих были заброшены. Также одним из требований была возможность самостоятельного хостинга. Мы знаем, что существует множество бесплатных и коммерческих push-сервисов.

Фичи
отправка сообщений через REST-API
принимать сообщения через WebSocket
управление пользователями, клиентами и приложениями
Плагины
Web-UI -> ./ui
CLI для отправки сообщений -> gotify/cli
Android-приложение -> gotify/android

https://github.com/gotify/server

👉 @golang_lib

💼 Хотите прокачаться в Go и расширить карьерные перспективы?

🚀Go — это скорость, производительность и надежность. Компании всё чаще выбирают его для своих проектов, а спрос на разработчиков стремительно растёт.

На курсе «Golang Developer. Professional» вы:

— Разберетесь в идиоматике Go и освоите продвинутые инструменты.
— Поработаете с реальными коммерческими задачами.
— Изучите алгоритмы и подходы, которые ценят ведущие IT-компании.
— Получите удостоверение о повышении квалификации.

🏆 Вы сможете разрабатывать высоконагруженные серверные приложения, работать с SQL и NoSQL, а главное — претендовать на позиции Middle и Senior.

👨‍💻 Пройдите вступительное тестирование и получите скидку до 15% по промокоду: GO_03 на обучение: https://vk.cc/cJUSou

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

Ужасно подробные ошибки в API: пишем на Go инструмент для работы с ними

Меня зовут Александр Лырчиков, я разрабатываю систему хранения данных TATLIN.UNIFIED в YADRO. СХД — сложная система, и, если при работе произошла ошибка, она должна своевременно и понятно сообщать пользователю об этом. В большинстве веб-сервисов для этого используют баннер с надписью «Что-то пошло не так», но такой способ уведомления нам не подходит.

Мы столкнулись с проблемой, когда переданных сообщений и HTTP-кодов уже не хватает. Поэтому разработали собственный инструмент для обработки ошибок Terror (TATLIN + error). В результате работа с кодом стала проще, мы получили красивый API, а пользователи — понятное описание ошибки и локализацию текста на разные языки. В этой статье расскажу, как мы создавали Terror, чтобы вы смогли повторить решение.

https://habr.com/ru/companies/yadro/articles/817719/

👉 @golang_lib

🧵 Три способа использовать каналы в Go

Каналы в Go — мощный инструмент для взаимодействия между горутинами. Рассмотрим три идиоматичных способа их использования:

1. Fan-out (расщепление задач)

Fan-out — это когда несколько воркеров читают из одного канала задач. Это позволяет обрабатывать задачи параллельно:

ch := make(chan int)
for i := 0; i < 3; i++ {
 go func() {
  for task := range ch {
   doWork(task)
  }
 }()
}

Задачи отправляются в ch, и любая из горутин может их подобрать и обработать.



2. Fan-in (агрегация результатов)

Fan-in — это сбор результатов от нескольких источников в один канал. Используется, когда у нас несколько генераторов данных:

ch1 := make(chan int)
ch2 := make(chan int)
out := make(chan int)

go func() {
 for {
  select {
  case v := <-ch1:
   out <- v
  case v := <-ch2:
   out <- v
  }
 }
}()

Мы слушаем оба канала и всё складываем в out, где далее можно агрегировать или обрабатывать данные.



3. Pipelines (конвейеры обработки)

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

func gen() <-chan int {
 out := make(chan int)
 go func() {
  for i := 0; i < 10; i++ {
   out <- i
  }
  close(out)
 }()
 return out
}

func square(in <-chan int) <-chan int {
 out := make(chan int)
 go func() {
  for v := range in {
   out <- v * v
  }
  close(out)
 }()
 return out
}

for v := range square(gen()) {
 fmt.Println(v)
}

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


https://www.dolthub.com/blog/2024-06-21-channel-three-ways/

👉 @golang_lib

💡 Структура CLI-приложения на Go

Когда мы пишем CLI на Go, важно грамотно организовать структуру проекта. Вот распространённый и удобный шаблон:

my-cli/
├── cmd/
│   ├── root.go
│   └── greet.go
├── internal/
│   └── greet/
│       └── greet.go
├── main.go
├── go.mod

📌 Основные моменты:

- main.go — точка входа. Здесь мы вызываем cmd.Execute().
- Папка cmd/ содержит все команды CLI. Например, greet.go реализует команду greet, а root.go — основную/root-команду.
- В internal/greet/greet.go размещаем бизнес-логику, отделяя её от логики CLI. Это улучшает читаемость, покрытие тестами и повторное использование кода.

📁 Пример содержимого cmd/greet.go:

var greetCmd = &cobra.Command{
    Use:   "greet",
    Short: "Выводит приветствие",
    Run: func(cmd *cobra.Command, args []string) {
        greet.SayHello()
    },
}

А в internal/greet/greet.go:

func SayHello() {
    fmt.Println("Привет от Go CLI!")
}

📦 Такой подход делает CLI-приложение масштабируемым и удобным для поддержки. Особенно если вы планируете добавлять новые команды или делегировать разработку другим.

https://www.bytesizego.com/blog/structure-go-cli-app

👉 @golang_lib

Примеры использования client-go — официальной Go-библиотеки для взаимодействия с Kubernetes API. Репозиторий содержит набор минималистичных, но рабочих программ, которые демонстрируют, как использовать client-go для различных задач:

- Получение списка Pod'ов
- Прослушивание событий (watch)
- Использование контроллеров
- Работа с workqueue
- Создание кастомных клиентов
- Реализация информеров
- Примеры c RBAC и настройкой доступа

Каждый пример максимально изолирован и понятен, что делает репозиторий отличной стартовой точкой для тех, кто хочет разобраться, как изнутри работает Kubernetes-клиент на Go. Особенно полезно для разработчиков операторов и контроллеров.

https://github.com/iximiuz/client-go-examples

👉 @golang_lib

Выжимаем из Go максимум производительности

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

Меня зовут Никита Галушко. Я старший программист-разработчик в отделе высоконагруженных систем и оптимизации ВКонтакте. В статье поделюсь, какие хитрости помогут использовать Go на полную мощность.

О чём будет речь в статье

🔹Расскажу про память, а именно про small-size объекты и интерфейс, покажу пару трюков со стеком.

🔹Поделюсь, как сильно может влиять на производительность BCE (Bounds Check Elimination) и почему не все циклы for-loop одинаково полезны.

🔹Раскрою особенности, которые текущий компилятор Go накладывает на наш код.

🔹Затрону такие темы, как оптимальная конвертация string -> []byte и []byte -> string, конкатенация и связанные с ней оптимизация, сортировка []string — это важно, так как в наших повседневных программах часто используются строки, и с типом string связано много мифов.

https://habr.com/ru/companies/vk/articles/824484/

👉 @golang_lib

🧠 Почему context.WithCancel может вызвать утечку goroutine

context.WithCancel — удобный способ завершать операции, но если не вызывать cancel(), вы получите утечку. Причём не всегда это очевидно.

Посмотрим:

func handler(w http.ResponseWriter, r *http.Request) {
 ctx, cancel := context.WithCancel(r.Context())
 // cancel не вызывается!
 go doSomething(ctx)
 w.Write([]byte("done"))
}

func doSomething(ctx context.Context) {
 select {
 case <-time.After(10 * time.Second):
  fmt.Println("done work")
 case <-ctx.Done():
  fmt.Println("canceled")
 }
}

Что здесь не так?

Если handler завершится раньше, чем doSomething, и cancel() не вызван — doSomething останется висеть, пока не истечёт r.Context() или time.After. И таких горутин может накопиться много, особенно при высоких нагрузках.

💡 Как избежать

1. Всегда вызывай cancel(), когда используешь context.WithCancel, даже если кажется, что это «не нужно».

ctx, cancel := context.WithCancel(r.Context())
defer cancel()

2. Если передаёшь контекст в goroutine — убедись, что она завершится, даже если вызывающая функция ушла.

context.WithCancel — мощный инструмент. Но без вызова cancel() ты легко создашь утечку, которую не поймаешь ни в логах, ни в профилях — только под нагрузкой.

👉 @golang_lib

Pragmatic go.mod bump

Недавно я открыл pull request, в котором просто обновил go.mod, и мне задали интересный вопрос:

> Почему ты обновляешь go.mod, если он и так работает?

Хороший вопрос. Короткий ответ: потому что это имеет значение.

Длинный ответ...

Что делает go mod tidy?

Он обновляет:

- go.mod:
- удаляет неиспользуемые зависимости;
- добавляет недостающие;
- обновляет версии go, toolchain, require и replace, если это необходимо.
- go.sum:
- добавляет хэши для новых зависимостей;
- удаляет хэши для неиспользуемых.

Что делает go mod tidy -go=1.xx?

То же самое, но моделируя, как если бы у вас был Go 1.xx. Это может быть полезно, если вы используете более старую версию Go, но хотите подготовить модуль к сборке на более новой версии, или наоборот.

Почему я обновляю go.mod?

Есть несколько причин.

Обновление версии Go

Когда я обновляю go, я также обновляю go.mod. Это позволяет понять, с какой версией Go должен работать проект. Это особенно важно для CI/CD и будущих участников команды.

Поддержание актуальности зависимостей

Иногда go mod tidy может подтянуть более свежую версию зависимости, особенно если у вас были временные изменения или вы что-то откатывали. Это помогает избежать накопления "грязи" в go.mod.

Удаление лишнего

Если вы удалили использование какого-либо пакета, но не запускали tidy, зависимость может остаться в go.mod и go.sum. Это лишний шум.

Минимизация различий

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

Безопасность

Иногда обновление зависимости может подтянуть фиксы для уязвимостей. Даже если вы не используете уязвимый код напрямую, он может быть в go.sum.

TL;DR

- go.mod и go.sum — это часть исходного кода, и за ними нужно ухаживать.
- go mod tidy помогает держать их в порядке.
- Обновление go.mod даже без изменения логики — это хорошая практика.

https://carlosbecker.com/posts/pragmatic-gomod-bump/

👉 @golang_lib

Шпаргалка по Go

👉 @golang_lib

Реальное время для логирования диагностики или как по-настоящему следить за вашими Go веб-приложениями

Логирование часто рассматривают как пассивный процесс: что-то записывается в файл, а вы потом когда-нибудь это прочтёте. Но иногда вам нужно видеть, что происходит прямо сейчас.

Рассматриваем, как можно настроить в Go веб-приложении потоковое диагностическое логирование в реальном времени без особых накладных расходов.

Идея простая: вы создаёте отдельный HTTP-эндпоинт, который отправляет новые логи по WebSocket-соединению клиенту. Таким образом, вы можете открыть специальную страницу в браузере и наблюдать за логами в реальном времени, как будто это встроенный "tail -f" прямо в ваше приложение.

В статье описывается:

- Как настроить логгер на основе стандартного log пакета;
- Как использовать github.com/gorilla/websocket для работы с WebSocket-соединением;
- Как обрабатывать несколько клиентов;
- Как фильтровать события логирования по уровню;
- Как сделать базовую аутентификацию для безопасного доступа к логам.

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

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

https://evilmartians.com/chronicles/realtime-diagnostic-logging-or-how-to-really-spy-on-your-go-web-apps

👉 @golang_lib