🚀 Golang Roadmap 2026 — продвинутый курс на русском

📌 О курсе
Это бесплатный open-source roadmap на русском языке. Внутри — 19 модулей, каждый со своей теорией, практикой, бесплатными ресурсами и финальным проектом. Программа собрана так, чтобы провести вас от полного нуля до уровня Senior/Staff Go Engineer за 12–18 месяцев при темпе 10–15 часов в неделю.

Главный принцип курса — практика > видосы. Каждую тему вы закрываете кодом: пишете, ломаете, чините, рефакторите. Любой модуль завершается мини-проектом, который можно положить в портфолио.

🎯 Кому подойдёт
🐹 Новичкам в Go — даже если до этого писали только на Python/JS/PHP
🛠 Backend-разработчикам с другого стека — хотите перейти на Go
📈 Junior Go-разработчикам — нужен путь до Middle/Senior
🚀 Middle-инженерам — закрыть пробелы в архитектуре, observability, distributed
🤖 Тем, кто хочет писать AI-инфраструктуру — модуль 18 специально про это

https://github.com/Develp10/golangroadmap2026

O(1) не значит «быстро»

Одна из самых частых ошибок в алгоритмах: считать, что O(1) всегда быстрее O(n).

На практике это не так.

O(1) означает только одно: время работы не растёт вместе с размером входных данных.

Но сама операция может быть дорогой.

Например, хеш-таблица формально даёт O(1) для поиска, но если данные не в кэше CPU, один cache miss может сделать её медленнее, чем простой линейный проход по маленькому массиву.

Именно поэтому в Go, Python и даже C-библиотеках для маленьких map/таблиц иногда используют обычный linear search.

Парадоксально, но:

O(n) при n = 16 и тёплом кэше может быть быстрее, чем O(1) с холодным cache miss.

Big O описывает асимптотический рост, а не реальную скорость на маленьких данных.

📌 HyperLogLog на Go простыми словами

Redis может примерно считать уникальные значения, почти не храня сами значения.

Идея такая:

- берём строку
- считаем от неё хеш
- первые биты выбирают ячейку
- остальные биты проверяем на количество нулей подряд
- чем длиннее серия нулей, тем более редкое событие мы увидели
- редкие события намекают, что элементов прошло много

Минимальный пример на Go:

package main

import (
 "fmt"
 "hash/fnv"
 "math/bits"
)

const registersCount = 16

type HyperLogLog struct {
 registers [registersCount]uint8
}

func hash64(s string) uint64 {
 h := fnv.New64a()
 _, _ = h.Write([]byte(s))
 return h.Sum64()
}

func (hll *HyperLogLog) Add(value string) {
 hash := hash64(value)

 // первые 4 бита выбирают регистр: 2^4 = 16
 index := hash >> 60

 // остальные биты используем для поиска серии нулей
 rest := hash << 4

 // сколько нулей подряд в начале
 zeros := uint8(bits.LeadingZeros64(rest) + 1)

 if zeros > hll.registers[index] {
  hll.registers[index] = zeros
 }
}

func main() {
 hll := HyperLogLog{}

 values := []string{
  "user_1",
  "user_2",
  "user_3",
  "user_1",
  "user_2",
  "user_4",
  "user_5",
 }

 for _, v := range values {
  hll.Add(v)
 }

 fmt.Println(hll.registers)
}

Это не полноценный Redis HyperLogLog, а понятная учебная версия.

Что тут важно:

• дубликаты дают тот же хеш
• один и тот же хеш попадает в тот же регистр
• регистр хранит только максимум найденных нулей
• сами user_1, user_2, user_3 не сохраняются
• память остаётся почти постоянной

В Redis всё серьёзнее: там 16 384 регистра, аккуратная математика для оценки cardinality и поправки на маленькие и большие значения.

Morph - генератор мапперов для Go, который закрывает одну из самых скучных частей backend-разработки: перекладывание данных между похожими типами.

Типичный кейс: у вас есть protobuf-модели, доменные структуры, DTO, database-типы и API-ответы. Поля почти одинаковые, но код всё равно приходится писать руками:

func MapFromRecipeToToRecipe(source *from.Recipe) to.Recipe {
    if source == nil {
        return to.Recipe{}
    }

    var target to.Recipe
    target.ID = to.RecipeID(source.RecipeId)
    target.Name = source.Name
    target.Servings = int(source.Servings)

    return target
}

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

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

Что поддерживает:

* structs и enums
* basic types, pointers, slices, arrays, maps
* nested structs
* concrete generic containers
* safe и настроенные type conversions
* вложенные сгенерированные мапперы
* пользовательские callables для сложной логики
* discovery готовых mapping-функций из указанных пакетов
* presets, чтобы не дублировать конфиг для типовых сценариев

Самый полезный случай - protobuf → idiomatic Go model. protoc часто генерирует не тот код, который хочется таскать по доменному слою: другие имена, другие типы, timestamp-обёртки, enum-формат, optional-поля. Morph позволяет описать правила один раз и дальше генерировать нормальные мапперы.

Запуск простой:

go install github.com/seeruk/morph/cmd/morph@latest
morph

Конфигурация живёт в morph.yaml, а сам инструмент можно использовать и как CLI, и как библиотеку внутри более сложных codegen-пайплайнов.

Хороший вариант для Go-проектов, где ручной mapping уже стал отдельным источником багов и мусорного кода.

GitHub:
https://github.com/seeruk/morph

#golang

Gortex индексирует репозитории в виде графа кода и открывает доступ к нему через CLI, MCP Server и веб-интерфейс. Это позволяет AI coding agents сокращать расход токенов до 50 раз.

* До 50 раз меньше токенов на ответ благодаря graph-native поиску.
* Заранее рассчитанный depth-3 reach index для impact analysis за доли миллисекунды.
* Одна установка автоматически настраивает все найденные AI coding agents на вашей машине.
* Доступен на macOS, Linux и Windows, релизы подписаны через Sigstore.

https://github.com/zzet/gortex

Open-source мониторинг без SaaS-привязки

CheckCle выглядит как интересная self-hosted альтернатива для мониторинга инфраструктуры, сервисов и приложений.

Проект даёт uptime-мониторинг, проверки HTTP, DNS, Ping и TCP-сервисов, распределённые региональные проверки, историю инцидентов, SSL и domain monitoring, public status pages, отчёты и алерты в Telegram, Slack, Discord, Matrix и email.

Главный плюс в том, что всё можно поднять у себя через Docker. Не нужен внешний SaaS, не нужно отдавать данные третьей стороне, не нужно платить за каждый монитор или сидеть в чужой панели.

По стеку тоже интересно: основа на Go, фронт на TypeScript, лицензия MIT. На GitHub у проекта уже около 2.7k звёзд, так что это не просто заброшенная утилита на вечер.

Подойдёт тем, кто хочет свой мини-UptimeRobot/Better Stack для VPS, pet-проектов, внутренних сервисов или небольшой команды.

Репозиторий: https://github.com/operacle/checkcle

GoPost - нативный API-клиент на Go + React через Wails, без Electron, аккаунтов и лишнего облака.

Главное:

1. около 15 МБ
2. работает офлайн
3. хранит всё plain JSON-файлами
4. можно версионировать коллекции в Git
5. есть GraphQL, WebSocket, SSE
6. импорт/экспорт .http
7. CLI-runner с JUnit для CI
8. response diff и extract переменных через JSONPath

По сути, это Postman для тех, кому нужен быстрый локальный инструмент без блоата и телеметрии.

GitHub: github.com/berksunduri/GOPost

Limen — модульная auth-библиотека для Go с подходом plugin-first.

Ядро даёт базовые интерфейсы, сессии и security primitives, а каждый способ аутентификации поставляется как отдельный Go-модуль.

То есть в проект можно импортировать только то, что реально нужно, без лишнего балласта.

Хороший подход для Go-сервисов, где auth хочется собирать как конструктор: минимальное ядро, отдельные провайдеры и меньше зависимостей в проде.

GitHub: https://github.com/thecodearcher/limen

#golang

Любопытная идея: протоколы, которые легко блокируются напрямую, можно сделать гораздо живучее, если запускать их не «голыми», а внутри отдельного туннеля.

Пример - catwire, кастомная виртуальная сеть на Go.

В этом кейсе через неё пробрасывают обычный VLESS без дополнительной маскировки и шифрования на стороне самого VLESS.

Фокус в том, что снаружи виден уже не прикладной протокол, а транспорт виртуальной сети.

Получается простой паттерн:

* VLESS живёт внутри приватного слоя
* внешний трафик идёт через catwire
* туннель берёт на себя сетевую обвязку
* блокировать сам прикладной протокол становится сложнее

Это хороший пример того, что устойчивость часто строится не вокруг одного «волшебного протокола», а вокруг правильной архитектуры: виртуальная сеть сверху, нужные сервисы внутри.

https://github.com/nktauserum/catwire

🔌 k8s-d2 - быстрый способ превратить Kubernetes-кластер в понятную схему

Когда кластер растёт, kubectl get pods уже не помогает понять архитектуру. Видно ресурсы, но не видно систему.

k8s-d2 решает это через диаграммы как код. Инструмент читает топологию Kubernetes-кластера и генерирует D2-файлы: пространства имён, workloads, сервисы, ingress и связи между ними.

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

Особенно полезно в командах, где Kubernetes уже живёт давно, а актуальная схема существует только в голове одного DevOps-а, который “сейчас в отпуске, но вроде всё помнит”.

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

https://github.com/vieitesss/k8s-d2

Кто-то разобрал Claude Code почти до винтика

learn-coding-agent - репозиторий для тех, кто хочет понять, как устроены современные coding agents не на уровне промо-страниц, а на уровне архитектуры.

Автор собрал разбор Claude Code по публичным источникам: цикл агента, систему инструментов, разрешения, работу с контекстом, сессии, подпроцессы, MCP, удалённые настройки, телеметрию и скрытые флаги.

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

https://github.com/justxor/Claudecourse/

Anthropic открыла reference harness для поиска уязвимостей с Claude

Anthropic выложила open-source пример того, как можно строить пайплайн для поиска и исправления уязвимостей с помощью Claude. Репозиторий называется Defending Code Reference Harness и уже собрал около 6.5K звёзд на GitHub.

Внутри — Claude Code skills для полного security-цикла:

* /threat-model
* /vuln-scan
* /triage
* /patch
* /customize

Сначала модель помогает построить threat model, потом сканирует код, помогает отфильтровать находки, ранжирует риски и предлагает патчи.

Отдельно есть автономный harness: он проходит путь recon → find → verify → report → patch и в референсной версии заточен под поиск memory-багов в C/C++ через Docker и ASAN.

GitHub: https://github.com/anthropics/defending-code-reference-harness