Полная программа для тех, кто хочет в 2026 году писать на Go в продакшене: от fmt.Println до распределённых систем, observability, AI-агентов и масштабирования на миллионы RPS.

Это бесплатный 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 специально про это

1. Свежий стек 2026 — generics, fuzzing, structured logging slog, OpenTelemetry, eBPF, Wasm, GenAI.
2. Никаких платных курсов — только бесплатные ресурсы и официальная документация.
3. Проект в каждом модуле — на выходе у вас 19 готовых пет-проектов + 3 крупных капстоуна.
4. Главный источник новостей по Go в Telegram — @Golang_google и папка каналов про Go.

• О курсе
• Программа курса
• Подробный разбор модулей
• Длительность по грейдам
• Как проходить курс
• Подробный план уроков
• Топ бесплатных ресурсов
• Главный источник новостей по Go
• Красные флаги — типичные ошибки
• ⚡ Конкуренция в Go — объяснение и примеры
• Лучшие практики Go
• 3 железных правила
• FAQ

Что изучаем: go run, go build, переменные, типы, zero values, control flow, массивы vs срезы, maps, структуры, методы и receiver-ы, интерфейсы (implicit), ошибки и errors.Is/As, defer, panic/recover, generics (1.18+), iterators (1.23+). Бесплатные ресурсы:

• A Tour of Go — официальный интерактив
• Effective Go — обязательно
• Go by Example — рецепты на каждый день
• Учебник Ushakov (бесплатный)
• YouTube: Nikolay Tuzov — Golang с нуля
• Книга: «The Go Programming Language» (Donovan, Kernighan) — главы 1–7 Проект модуля: CLI-утилита gocount — считает строки/слова/байты в файлах (аналог wc).

Что изучаем: go mod init/tidy/why/graph, go work, replace, vendoring, версионирование (semver), golangci-lint, gofumpt, goimports, Taskfile.yml, Makefile, pre-commit hooks, GitHub Actions для Go. Бесплатные ресурсы:

• Go Modules Reference
• golangci-lint docs
• Task — современный Make
• Статья: Go Workspaces by Robert Griesemer Проект модуля: монорепо с 2 модулями, единый Taskfile, CI на GitHub Actions с линтером и тестами.

Что изучаем: горутины, go-statement, каналы (buffered/unbuffered), select, for range ch, close, sync.Mutex/RWMutex, sync.WaitGroup, sync.Once, sync.Pool, atomic, context.Context (cancel/timeout/value), race detector (go run -race), паттерны: worker pool, fan-in/fan-out, pipeline, semaphore, errgroup. Бесплатные ресурсы:

• Go Concurrency Patterns (Pike)
• Книга: «Concurrency in Go» Katherine Cox-Buday (главы в открытом доступе)
• Курс Concurrency in Go — Ardan Labs (open-source)
• YouTube: Бакалавр Computer Science — конкурентность Проект модуля: многопоточный краулер сайтов с rate limiting, retries и graceful shutdown.

Что изучаем: io.Reader/Writer идиомы, bufio, os (env, signals, fs), net/http сервер и клиент, encoding/json + кастомные MarshalJSON, encoding/xml, time (часовые пояса, monotonic), errors (wrap, unwrap), log/slog (1.21+) — structured logging. Бесплатные ресурсы:

• pkg.go.dev/std — официальная документация
• Go Blog — slog tutorial
• Статьи: Dave Cheney — practical Go Проект модуля: HTTP-сервис-агрегатор RSS с structured logging через slog.

Что изучаем: testing.T, table-driven tests, subtests, t.Parallel(), fuzzing (testing.F), benchmarking (testing.B), coverage, golden files, моки (gomock, mockery, testify/mock), httptest, iotest, integration через testcontainers-go. Бесплатные ресурсы:

• Go Testing — официальный туториал
• Learn Go with Tests — лучший бесплатный курс TDD на Go
• Go Fuzzing Проект модуля: библиотека для парсинга промокодов с 95%+ покрытием, fuzz-тестами и benchmark-ами.

Что изучаем: net/http + ServeMux (1.22+), роутеры chi, gin, echo, middleware (auth, recover, rate limit, CORS), валидация (go-playground/validator), OpenAPI 3 (oapi-codegen), huma, fiber, graceful shutdown, server-timing, SSE и WebSocket. Бесплатные ресурсы:

• Alex Edwards — Let's Go (book, бесплатные главы)
• chi docs
• OpenAPI Generator for Go Проект модуля: REST API linkshrt (аналог bit.ly) с auth, rate-limit, OpenAPI и Docker.

Что изучаем: database/sql, pgx, sqlc, squirrel, миграции (goose, atlas), индексы, EXPLAIN ANALYZE, транзакции и уровни изоляции, connection pool, go-redis, кэширование (cache-aside, write-through), ent и bun. Бесплатные ресурсы:

• Use the Database Slow Query Log
• pgx tutorial
• PostgreSQL для разработчика — Postgres Pro (RU) Проект модуля: сервис подписок с PostgreSQL (sqlc) + Redis (idempotency keys) + миграциями.

Что изучаем: protobuf 3, buf CLI, кодогенерация (protoc-gen-go, protoc-gen-go-grpc), unary/server-stream/client-stream/bidi-stream, deadlines, interceptors, grpc-gateway, reflection, connect-go, twirp. Бесплатные ресурсы:

• gRPC Basics — официальный туториал
• Buf docs
• YouTube: gRPC + Go — TechSchool Проект модуля: микросервис user-svc + order-svc через gRPC streaming, REST-фасад через gRPC-Gateway.

Что изучаем: Clean Architecture, Hexagonal (ports & adapters), Vertical Slice, DDD-lite (entity, value object, repository, aggregate), DI без магии (wire, fx), функциональные опции, error wrapping стратегии, layered конфиг (viper, koanf). Бесплатные ресурсы:

• go-clean-template — Evrone
• Standard Go Project Layout (с оговорками)
• Статьи: Three Dots Labs — Wild Workouts Проект модуля: рефакторинг проекта модуля 05 в чистую архитектуру + DI через wire.

Что изучаем: OpenTelemetry для Go, structured logging (slog + correlation id), traces (Jaeger/Tempo), metrics (Prometheus), pprof через HTTP, expvar, dashboards в Grafana, алёрты в Alertmanager, log levels стратегия. Бесплатные ресурсы:

• OpenTelemetry Go SDK docs
• Prometheus client_golang examples
• Grafana University (бесплатно) Проект модуля: добавить полную observability к сервисам из 07: traces + metrics + structured logs + Grafana дашборд.

Что изучаем: go test -bench, benchstat, pprof (cpu, mem, goroutine, mutex, block), escape analysis (-gcflags='-m'), GOGC и GOMEMLIMIT (1.19+), sync.Pool, lock-free структуры, false sharing, prealloc slice/map, string interning, PGO (Profile-Guided Optimization). Бесплатные ресурсы:

• High Performance Go Workshop — Dave Cheney
• Go Performance Tuning — Bartosz Mika
• pprof tutorial — Julia Evans Проект модуля: оптимизировать REST API из модуля 05 — поднять RPS в 5–10 раз через профилирование.

Что изучаем: OWASP Top 10 в контексте Go, JWT (RS256 vs HS256), OAuth2 / OIDC, TLS (mTLS), crypto/*, secrets management (Vault, SOPS), supply chain attacks, govulncheck, gosec, CSRF, SQL injection, SSRF, RCE через unsafe deserialization. Бесплатные ресурсы:

• OWASP Go Secure Coding Practices
• Go Security Best Practices — Snyk
• govulncheck blog post Проект модуля: аудит безопасности проекта 05/08, внедрение JWT + mTLS между сервисами + govulncheck в CI.

Что изучаем: multi-stage Dockerfile (distroless), Docker Compose, Kubernetes (Pod/Deployment/Service/Ingress/ConfigMap/Secret), Helm charts, Kustomize, ArgoCD, Terraform для облака (AWS/GCP/Yandex), GitOps workflow, kubectl мастерство. Бесплатные ресурсы:

• Kubernetes Up & Running — free chapters
• Learn Kubernetes the Hard Way (Kelsey Hightower)
• Helm docs
• YouTube: TechWorld with Nana — Kubernetes Проект модуля: деплой 3-сервисов из модуля 09 в Kubernetes (kind/minikube) + Helm + ArgoCD.

Что изучаем: Kafka (партиции, оффсеты, consumer groups, exactly-once), NATS (Core, JetStream, KV), RabbitMQ, outbox pattern, idempotency keys, retries с backoff, dead letter queue, sagas (orchestration vs choreography), event-driven архитектура. Бесплатные ресурсы:

• Kafka: The Definitive Guide — free O'Reilly
• NATS by Example
• Watermill — фреймворк для event-driven Go Проект модуля: order-saga через NATS JetStream + outbox table в PostgreSQL.

Что изучаем: CAP, PACELC, consistency models (linearizable, sequential, eventual), Raft / Paxos (на уровне понимания), distributed locks (etcd, Redis Redlock), leader election, vector clocks, event sourcing + CQRS, Two-Generals, Byzantine fault tolerance (basics). Бесплатные ресурсы:

• Книга «Designing Data-Intensive Applications» (Kleppmann) — обязательно
• MIT 6.824 Distributed Systems — лекции бесплатно
• The Raft paper + interactive visualisation Проект модуля: свой mini key-value store с Raft (на базе hashicorp/raft) на 3 нодах.

Что изучаем: service mesh (Istio, Linkerd), API Gateway (KrakenD, Kong), circuit breaker (sony/gobreaker), retries, timeouts, bulkhead, resilience-go, feature flags (Unleash), blue-green / canary deploys, contract testing (Pact). Бесплатные ресурсы:

• microservices.io patterns — Chris Richardson
• Istio docs
• Release It! — Michael Nygard (главы в открытом доступе) Проект модуля: добавить circuit breaker, retries, timeouts в проект 09; canary deploy через ArgoCD.

Что изучаем: capacity planning (back-of-envelope), CDN, шардирование, репликация (sync vs async), кэширование (LRU, LFU, TinyLFU), очереди, consistent hashing, gossip protocols, geo-replication, multi-tenancy, мульти-регион, RTO/RPO. Бесплатные ресурсы:

• System Design Primer — must-have
• ByteByteGo (бесплатные посты)
• YouTube: Hussein Nasser Проект модуля: письменный системный дизайн Twitter-clone на Go (можно как ADR-документ в репо).

Что изучаем: Go runtime (GMP scheduler), garbage collector (tri-color, write barriers), unsafe (когда оправдано), cgo (и почему лучше без него), tinygo для Wasm и embedded, eBPF на Go (cilium/ebpf), plugin, Wazero для запуска Wasm на сервере. Бесплатные ресурсы:

• Go internals — Bartosz Mika
• Go scheduler — Ardan Labs deep dive
• eBPF Tutorial — Cilium Проект модуля: eBPF-программа на Go, считающая TCP-соединения по PID.

Что изучаем: Ollama клиент на Go, langchaingo, RAG (Retrieval Augmented Generation), vector databases (pgvector, Qdrant, Weaviate), streaming-обработка (benthos), embeddings, function calling, MCP-серверы на Go. Бесплатные ресурсы:

• langchaingo examples
• Building LLM apps with Go — Eli Bendersky
• Qdrant Go SDK quickstart Проект модуля: RAG-чат-бот по документации Go (pgvector + Ollama + langchaingo + gRPC API).

Это не дедлайны, а ориентиры. Кто-то проходит за 8 месяцев, кто-то за 2 года — оба варианта норма.

1. Установите Go 1.23+ с go.dev/dl и настройте gopls в редакторе.
2. Клонируйте репозиторий — внутри /course лежат markdown-файлы по каждому модулю.
3. Идите по порядку — модули зависят друг от друга. Перепрыгивать опасно.
4. Не смотрите видосы пассивно — открыли видео → пишете тот же код параллельно.
5. Делайте проект каждого модуля — без проекта модуль не считается пройденным.
6. Ведите блог-конспект — хоть в /notes репозитория. Объяснил себе → понял.
7. Подпишитесь на @Golang_google — там разбирают свежие фичи Go и вакансии.

Здесь — расширенный план первого квартала (модули 00–04). Полные планы остальных модулей лежат в /course/<NN>-*.md.

• Урок 1.1 «Hello, World правильно». Установка Go, GOPATH vs go modules, go run, go build, кросс-компиляция. Практика: написать 5 версий hello — с аргументами, env-переменными, stdin, JSON-выводом, exit codes.
• Урок 1.2 Скалярные типы и литералы. Числа (int vs int64), string vs []byte, rune, typed/untyped константы, iota. Практика: калькулятор BMI с обработкой некорректного ввода.
• Урок 1.3 Управление потоком. if, for (3 формы), switch (type switch), goto (зачем?). Практика: FizzBuzz, реализованный 4 разными способами; решение задачек с Exercism Go track.
• Урок 1.4 Функции, multiple return, named returns, variadic, замыкания. Практика: набор функций для статистики ([]float64 → mean, median, mode, stdev).

• Урок 2.1 Массивы vs слайсы: длина, capacity, underlying array, append подводные камни, копирование. Практика: реализовать свой Stack и Queue на слайсах с тестами.
• Урок 2.2 Maps: zero value, iteration order, delete, конкурентный доступ. Практика: word-frequency counter, читающий большой текст и выдающий топ-N слов.
• Урок 2.3 Strings, runes, UTF-8, strings.Builder, bytes.Buffer. Практика: транслитерация русский ↔ латиница.
• Урок 2.4 Pointers, value vs pointer receivers, когда копирование вредит. Практика: бенчмарк big-struct value vs pointer.

• Урок 3.1 struct, теги (json, db, validate), embedding (composition over inheritance). Практика: модель Order с JSON-сериализацией и валидацией.
• Урок 3.2 Методы, value vs pointer receivers, method sets. Практика: тип Money с безопасной арифметикой (без float).
• Урок 3.3 Интерфейсы — implicit, пустой интерфейс, type assertion, type switch, io.Reader/Writer идиома. Практика: написать свой io.Reader, который сжимает строку в gzip on-the-fly.
• Урок 3.4 Errors как values: errors.New, fmt.Errorf("%w", ...), errors.Is/As, sentinel vs typed vs opaque ошибки. Практика: библиотека парсинга конфига с собственными типами ошибок.

• Урок 4.1 defer, panic, recover — паттерны и анти-паттерны.
• Урок 4.2 Generics (1.18+): type parameters, constraints, comparable, any. Практика: написать generic Filter, Map, Reduce.
• Урок 4.3 Iterators (1.23+) — range over func. Практика: переписать word-counter из 2.2 как iterator.
• Финальный проект: CLI-утилита gocount — flags, чтение stdin/файлов, glob, бенчмарк против системного wc. Покрытие тестами ≥ 80%.

• Урок 1 go mod под микроскопом: версии, replace, retract, minimum version selection.
• Урок 2 go work и монорепо.
• Урок 3 Линтеры: golangci-lint конфиг для prod-проекта, gofumpt, gci, betteralign.
• Урок 4 Taskfile.yml vs Makefile; pre-commit hooks (lefthook).
• Урок 5 GitHub Actions workflow для Go (matrix Go-версий, cache, codecov).
• Финальный проект: монорепо-шаблон со всем настроенным CI и pre-commit.

• Урок 1 Горутины: стек, цена создания, GMP-модель в общих чертах.
• Урок 2 Каналы: buffered vs unbuffered, направление, close, range, nil-channel паттерн.
• Урок 3 select и таймауты, default-ветка, идиома done-channel.
• Урок 4 Race detector в действии: пишем код с гонкой, ловим её -race.

• Урок 5 sync.Mutex/RWMutex: когда RW даёт выигрыш, deadlock-стратегии.
• Урок 6 sync.WaitGroup, sync.Once, sync.Pool (когда вредит).
• Урок 7 atomic и lock-free счётчики; happens-before.
• Урок 8 context.Context — cancel, timeout, deadline, value (и почему value лучше избегать).

• Урок 9 Worker pool с back-pressure.
• Урок 10 Pipeline + fan-in/fan-out.
• Урок 11 errgroup, semaphore, singleflight.
• Урок 12 Graceful shutdown сервиса: signal → ctx.Done → wait → exit.

• Финальный проект: многопоточный web-crawler с rate limit на хост, depth limit, retries (exponential backoff), persisting в BoltDB, graceful shutdown по SIGTERM.

• Урок 1 io.Reader/Writer композиция: TeeReader, MultiReader, LimitReader.
• Урок 2 bufio правильно: Scanner-ловушки на длинных строках.
• Урок 3 os: env, signals, process management, file system.
• Урок 4 net/http server: ServeMux 1.22+, middleware-цепочки, server timeouts.
• Урок 5 net/http client: transport, retries, connection pooling, timeouts ВЕЗДЕ.
• Урок 6 encoding/json глубже: json.Decoder стримом, custom Marshal/Unmarshal, omitempty-нюансы.
• Урок 7 time без боли: zones, monotonic clock, mock-абстракции для тестов.
• Урок 8 log/slog (1.21+) — handlers, attributes, source, context.
• Финальный проект: RSS-агрегатор с structured logging, retries, graceful shutdown.

• Урок 1 testing.T + subtests + table-driven (с t.Run).
• Урок 2 t.Parallel(), t.Cleanup(), helper functions.
• Урок 3 Моки: testify/mock, gomock, mockery — pros/cons.
• Урок 4 httptest.Server + httptest.ResponseRecorder.
• Урок 5 Integration tests через testcontainers-go (Postgres, Redis в Docker).
• Урок 6 Fuzzing (testing.F) — пишем и находим реальный баг.
• Урок 7 Benchmarks + benchstat для сравнения.
• Финальный проект: библиотека парсинга промокодов с 95% coverage, fuzz-найденными багами и benchmark-сравнением 2 реализаций.

Полные планы по модулям 05–18 — в /course/05-web.md ... /course/18-ai-data.md. Каждый файл уже содержит конкретные уроки, ссылки и проектные задания.

• A Tour of Go — go.dev/tour
• Effective Go — go.dev/doc/effective_go
• Learn Go with Tests — quii.gitbook.io
• The Go Programming Language (главы доступны, образцы — gopl.io)
• Designing Data-Intensive Applications — Kleppmann (для модулей 13–16)
• Concurrency in Go — Cox-Buday (главы 1–3 в открытом доступе)

• Nikolay Tuzov — Golang с нуля (RU)
• Ardan Labs Ultimate Go (EN, open-source)
• TechSchool — Go + gRPC
• JustForFunc — Francesc Campoy (EN)
• Anthony GG — Go projects (EN)

• Exercism Go track — задачки с ментором
• Gophercises — 20 пет-проектов
• Go by Example — рецепты
• Project Euler на Go — алгоритмы
• Advent of Code на Go

• Dave Cheney — practical Go
• Eli Bendersky
• Three Dots Labs
• Go Weekly
• Telegram: @Golang_google — главный русскоязычный канал

• pkg.go.dev/std — стандартная библиотека
• Go Language Specification — обязательно к прочтению на уровне Middle+
• Go Memory Model — для модуля 02

Если вы пишете на Go в 2026 — подпишитесь, это сэкономит часы поиска:

• 🥇 @Golang_google — главный русскоязычный канал по Go. Свежие фичи, статьи, разбор PR в Go core, вакансии Middle/Senior, мемы. Это первое, что должно быть в подписках.
• 📂 Папка Telegram «Go-ресурсы» — собранная коллекция каналов: новости, чаты по Go, вакансии, материалы для собесов. Добавляется одной кнопкой.

Дополнительно стоит мониторить:

• Gophers Slack — англоязычное community №1, есть канал #russian
• r/golang — субреддит
• Hacker News tag golang

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

1. «Я смотрю курс, но не пишу код». Пассивный просмотр видосов не даёт навыка. Правило: каждые 10 минут видео → 20 минут самостоятельной практики.
2. Игнорирование go vet, golangci-lint и race detector. Если запускаете тесты без -race — вы ловите гонки в проде, а не локально.
3. Прятать ошибки через _. f, _ := os.Open(...) — классика. В Go ошибки — часть контракта функции, их обрабатывают, а не глотают.
4. Делать всё через интерфейсы «на всякий случай». Интерфейс пишется на стороне потребителя и только когда есть ≥ 2 реализации. Преждевременная абстракция — главный анти-паттерн в Go.
5. Goroutine без context и без WaitGroup/errgroup. Любая горутина, которая не умеет завершаться по сигналу — потенциальная утечка.
6. panic вместо ошибки. panic — только для невосстановимых ситуаций (битый инвариант), не для «не нашёл юзера в БД».
7. Один большой pkg/utils. Признак отсутствия архитектуры. Разносите по доменным пакетам.
8. Глобальные переменные и init-магия. Усложняет тесты, делает порядок инициализации непредсказуемым.
9. Тесты только на happy path. Edge cases, ошибочные пути, конкурентность — без них тест бесполезен.
10. «У меня нет времени на pprof / OpenTelemetry». На Senior без observability и профилирования не берут. Закладывайте их в проект с первого коммита.
11. Копипаста из ChatGPT/Copilot без понимания. AI — помощник, не автор. Если не можете объяснить каждую строку — переписывайте.
12. Перестали читать стандартную библиотеку. Исходники net/http, sync, context — лучший учебник по идиомам Go.
13. Игнор slog, тащат logrus/zap в новые проекты. С 1.21+ структурное логирование есть в стандартной библиотеке. Используйте.
14. Не знают, что такое escape analysis. На Middle+ это базовый инструмент оптимизации.
15. Отказ от собеседований «пока не готов». Собеседования — лучший фидбек. Идите даже если не готовы — узнаете, что качать.

Это сборник идиом и инженерных правил, которые отличают код Junior от кода Senior. Каждый пункт — то, что вы будете слышать на ревью в любой нормальной Go-команде.

• Имена пакетов — короткие, нижний регистр, без подчёркиваний: user, auth, httputil. Никаких user_service или userService. Пакет utils / common / helpers — запах, режьте по доменам.
• Пакет — это API. Экспортируйте минимум: MarshalJSON — да, внутренний parseHeader — нет. Чем меньше публичная поверхность, тем проще менять реализацию.
• Не делайте циклические импорты. Если возникает желание — значит, домен разрезан неправильно. Выносите общие типы в отдельный пакет (domain, model) или объединяйте.
• Файлы внутри пакета группируйте по фиче, а не по типу. user_repository.go, user_service.go — лучше, чем models.go, services.go, repositories.go.
• internal/ — ваш друг. Всё, что не должно импортироваться извне модуля, кладите в internal/. Go-компилятор сам запретит.
• Не плодите подпакеты раньше времени. Один файл — нормально. Разделение на пакеты делайте, когда видно границу ответственности.

• Соблюдайте gofmt/gofumpt. Споров о стиле в Go нет — есть инструмент. Поставьте в pre-commit hook.
• Короткие имена в коротком скоупе, длинные — в широком. i в цикле — норма; userRepositoryFactory в пакете user — избыточно (просто Factory).
• Аббревиатуры пишем единым регистром: userID, HTTPServer, URLParser. Не userId и не HttpServer.
• Getter без Get: u.Name(), не u.GetName(). Setter — с Set: u.SetName(...).
• Имя интерфейса = действие + er: Reader, Writer, Closer, Stringer. Интерфейс с одним методом — особенно ценный.
• Receiver — короткий и консистентный: u *User, не this, не self, не user. И во всех методах одинаковый.

• Ошибка — это значение. Возвращайте, проверяйте, оборачивайте. Никаких исключений.
• Оборачивайте с контекстом: fmt.Errorf("create user: %w", err). Цепочка %w позволяет потом errors.Is/As.
• Не логируйте и не возвращайте одновременно. Логирует только тот, кто решил, что ошибка обработана. Иначе одна ошибка превращается в три записи в логе.
• Sentinel-ошибки — для известных ситуаций: var ErrNotFound = errors.New("not found"). Сравнение через errors.Is.
• Типизированные ошибки — когда нужны детали: type ValidationError struct { Field, Msg string }. Сравнение через errors.As.
• Не сравнивайте через err.Error() == "..." — это хрупкая привязка к тексту.
• panic только для невосстановимого: битый инвариант, невозможная ветка, init-ошибка. Бизнес-ошибки — return err.
• defer с проверкой ошибки: defer func() { if cerr := f.Close(); cerr != nil { err = errors.Join(err, cerr) } }() — особенно для Close на записи.

• Don't communicate by sharing memory; share memory by communicating — классическая мантра. Но если канал тащить не надо — sync.Mutex чище.
• Любая горутина должна знать, как умереть. context.Context или done-канал — обязательно. Иначе утечка.
• Не запускайте go f() в библиотечных функциях, если не задокументировали это. Управление горутиной — ответственность вызывающего.
• context.Context — первый параметр функции, имя ctx. Не храните в struct (кроме особых случаев типа request-scoped объектов).
• Не передавайте *sync.Mutex по значению — копируется состояние блокировки. Используйте указатель или встраивайте по значению в структуру (она тоже не должна копироваться — go vet подскажет).
• sync.WaitGroup.Add — до go, не внутри горутины. Иначе race.
• errgroup вместо ручного WaitGroup, когда нужна агрегация ошибок и cancel при первой.
• sync.Pool — только для дорогих объектов, которые реально переиспользуются. На мелочи даёт минус.
• Buffered channel size = N — это не оптимизация, это бэк-прешер на N сообщений. Думайте про это как про очередь.
• Закрывает канал только отправитель. Получатель — никогда. Иначе send on closed channel panic.
• Всегда тестируйте с -race. Локально, в CI, в pre-merge — везде.

• Accept interfaces, return structs. Параметры — узкие интерфейсы (io.Reader), возврат — конкретный тип. Так клиенту проще, чем гадать, что прячется за интерфейсом.
• Маленькие интерфейсы лучше больших. io.Reader (1 метод) переиспользуется тысячами библиотек. Repository с 15 методами — нет.
• Интерфейсы определяет потребитель, не реализатор. Не пишите UserRepository в пакете user и не реализуйте его там же. Пакет service сам объявит, что ему нужно от хранилища.
• any (он же interface{}) — крайнее средство. С generics 1.18+ почти всегда есть лучше.
• Не делайте Service god-object. Если структура зависит от 10 интерфейсов — она делает слишком много.

• Table-driven tests — стандарт de facto. Один цикл, понятный diff, легко добавлять кейсы.
• t.Parallel() в каждом тесте, где можно. Catch race conditions раньше + быстрее CI.
• t.Cleanup() вместо defer — корректнее работает с параллельными подтестами.
• Не моки ради моков. Моким то, что выходит за процесс (DB, HTTP, gRPC). Чистые функции моками не покрывают — это превращает тест в проверку реализации, а не поведения.
• Integration тесты — через testcontainers-go. Реальный Postgres/Redis в Docker лучше любого мока.
• Fuzzing — для парсеров, валидаторов, кодеков. Запустите на 10 минут — найдёте баги, которые table-driven никогда не покрывал бы.
• Покрытие — не цель, а индикатор. 80% с осмысленными тестами лучше 100% с проверкой геттеров.
• testdata/ — для фикстур. Go-toolchain игнорирует эту папку при сборке.

• Timeouts на сервере — обязательно: ReadHeaderTimeout, ReadTimeout, WriteTimeout, IdleTimeout. Дефолтный http.Server{} без них — приглашение к slowloris.
• Timeouts на клиенте — тоже. http.DefaultClient без таймаута — мина замедленного действия. Создавайте свой http.Client.
• context.Context в каждый запрос. http.NewRequestWithContext — стандарт.
• r.Body.Close() после io.ReadAll — иначе утечка соединения из пула.
• Не используйте http.Get/Post в продакшене — у них нет таймаутов и контекста.
• Graceful shutdown: srv.Shutdown(ctx) по сигналу SIGTERM, дайте 10–30 секунд, чтобы инфлайт-запросы доехали.
• Middleware — цепочкой, в правильном порядке: recover → request id → logging → tracing → auth → rate limit → handler.
• Не паникуйте в хендлере. Recover-middleware ловит panic и возвращает 500, но это последняя линия обороны, не норма.
• Версионируйте API с первого дня: /v1/users. Менять контракт без версии — ломать клиентов.

• Connection pool — настраивайте под нагрузку. SetMaxOpenConns, SetMaxIdleConns, SetConnMaxLifetime. Дефолты — не для прода.
• Всегда QueryContext/ExecContext — версии без контекста зависнут навечно при проблемах с БД.
• Транзакция — короткая. Никаких HTTP-вызовов и долгих расчётов внутри BEGIN ... COMMIT. Только работа с БД.
• Откат через defer: defer tx.Rollback() сразу после Begin. Commit отменит rollback. Безопасно и идиоматично.
• sqlc или pgx напрямую > ORM. В Go ORM-ы дают мало пользы и много магии.
• Миграции — версионируемые и идемпотентные (goose/atlas). Никаких ALTER TABLE руками в проде.
• Индексы под реальные запросы, не «на всякий случай». EXPLAIN ANALYZE — ваш главный инструмент.
• N+1 запросов — главный убийца перформанса. JOIN или batch-загрузка.

• Сначала измерь, потом оптимизируй. pprof + benchmark + benchstat. Интуиция врёт.
• Preallocate slices/maps: make([]T, 0, n) и make(map[K]V, n) — экономит реаллокации.
• Избегайте fmt.Sprintf в hot path — рефлексия дорогая. Используйте strconv и strings.Builder.
• Escape analysis читайте: go build -gcflags='-m'. Что уехало в кучу — кандидат на оптимизацию.
• GOMEMLIMIT (1.19+) — soft limit на память, спасает от OOM при кратковременных всплесках.
• PGO (Profile-Guided Optimization) — бесплатные 5–15% перформанса с 1.21+. Просто положите default.pgo рядом с main.go.
• sync.Pool — для аллокаций, не для коннектов. Коннекты — это другой контракт жизни.
• Не страдайте микро-оптимизациями в коде, который вызывается 10 раз в день. Оптимизируйте hot path.

• log/slog (1.21+) — стандарт. Никаких logrus/zap в новых проектах без причины.
• Structured logging, не fmt.Printf-style. slog.Info("user created", "id", u.ID, "email", u.Email) — поля, не интерполяция.
• Не логируйте PII в plain text: пароли, токены, email-ы. Маскируйте или хешируйте.
• Correlation/trace id во всех логах запроса. Без этого распределённая трассировка бесполезна.
• Логи — это события, метрики — это числа, трейсы — это причинно-следственная цепочка. Не путайте, не подменяйте одно другим.
• OpenTelemetry — единый стандарт для traces/metrics/logs. Не пишите кастомные клиенты.
• pprof всегда включён в проде на отдельном порту за auth. Когда сервис тормозит, у вас 30 секунд на снятие профиля.

• govulncheck в CI — на каждый PR. Бесплатно ловит известные CVE в зависимостях.
• gosec для статанализа. Поможет с crypto/md5, hardcoded credentials и подобным.
• TLS везде. mTLS между сервисами. Никаких InsecureSkipVerify: true в проде.
• JWT — RS256, не HS256. Симметричный ключ утечёт.
• Secrets — через Vault/SOPS/cloud KMS, не в .env и не в Git.
• Валидация ввода на границе. Доверяете только тому, что сами проверили.
• Rate limiting на уровне gateway и приложения. Двойной слой.
• Update Go регулярно. Минорные релизы — закрытые CVE.

• Минимизируйте зависимости. Каждая внешняя библиотека — потенциальный CVE, конфликт версий, и просто чужой код в вашем бинаре.
• Проверяйте go.sum в Git. Без него go mod download может скачать что угодно.
• replace — только локально, не в релизах. Иначе ломаете downstream.
• go mod tidy — на каждый коммит. CI должен это проверять.
• Pin major-версии в импортах: v2/v3 в пути модуля. Breaking changes не должны быть тихими.

• Graceful shutdown — обязательно. SIGTERM → stop accepting → wait inflight → exit.
• Health checks — раздельно: /livez (жив ли процесс) и /readyz (готов ли принимать трафик). Kubernetes их различает.
• Конфиг через env + flags + файл, в таком порядке приоритета. viper/koanf это умеют из коробки.
• 12-factor app — читайте, это не догма, а проверенный список граблей.
• Distroless Docker image для финального бинаря: gcr.io/distroless/static. Нет shell — меньше attack surface, ещё и весит мало.
• Multi-stage Dockerfile: builder + minimal runtime. Никаких golang:1.23 в проде.
• CGO_ENABLED=0 по умолчанию. Статический бинарь — деплоится куда угодно.
• Версия и commit hash в /version endpoint. -ldflags "-X main.version=..." при сборке.

• Маленькие PR. 200 строк ревьюится за 30 минут, 2000 — не ревьюится вообще.
• Один PR = одно изменение. Рефактор и новая фича — отдельно.
• Тесты в том же PR, что и код. «Тесты добавлю потом» = «никогда».
• Ревью — про код, не про человека. «Этот метод можно упростить» вместо «ты не понимаешь Go».
• Conventional commits: feat:, fix:, docs:, refactor:. Это даёт автогенерацию changelog и понятную историю.
• ADR (Architecture Decision Records) — для важных решений. Через год вы забудете, почему выбрали NATS, а не Kafka.

📌 Шпаргалка по идиомам в одном месте: Go Code Review Comments, Effective Go, Uber Go Style Guide.

Конкуренция (concurrency) — одно из главных преимуществ Go. Горутины весят ~2 КБ (против ~1–8 МБ у потоков ОС), планировщик GMP позволяет запускать миллионы горутин на обычном железе.

Горутина — лёгкая единица конкурентного выполнения. Запускается через go func(). Не то же самое, что поток ОС.

Канал — типизированная труба для общения между горутинами. Небуферизованный блокирует отправителя до получения; буферизованный — пока не заполнен.

select — мультиплексирование каналов. Выполняет первую готовую ветку; при нескольких готовых — случайную.

sync.Mutex / RWMutex — защита общего состояния. RWMutex даёт выигрыш при много читателей / мало писателей.

context.Context — стандарт отмены, таймаутов и deadline-ов. Первый параметр любой функции, работающей с сетью или БД.

errgroup — управление группой горутин с агрегацией ошибок и авто-отменой контекста при первой ошибке.

Полный набор примеров с объяснениями — в отдельном файле:

📄 course/03-concurrency-examples.md

Что внутри:

• Уровень 0: первый go func(), sync.WaitGroup
• Уровень 1: небуферизованные и буферизованные каналы, select, pipeline
• Уровень 2: Mutex, RWMutex, sync.Once, sync/atomic
• Уровень 3: context.WithCancel, WithTimeout, передача значений
• Уровень 4: Worker Pool, Fan-Out/Fan-In, Pipeline, Semaphore
• Уровень 5: errgroup, singleflight, Rate Limiter
• Уровень 6: Graceful Shutdown HTTP-сервера, полный Worker Pool с метриками, обнаружение Data Race

1. Любая горутина должна уметь завершиться — передавай context.Context или done-канал.
2. Закрывает канал только отправитель — никогда получатель.
3. sync.WaitGroup.Add() вызывается до go, не внутри горутины.
4. Тестируй с go test -race — гонки в тестах лучше, чем в проде.
5. Не храни context в структурах — передавай как первый параметр функции.

1. Каждый модуль закрывается проектом. Без проекта — модуль не пройден.
2. Каждый проект коммитится на GitHub. Публичный repo с README и тестами — ваш портфель.
3. Каждую неделю пишете заметку «что узнал» — в /notes или личный блог. Это закрепляет знание.

❓ Можно без опыта программирования?
Можно, но будет тяжело. Сначала пройдите CS50 (бесплатно) — базовый CS и алгоритмы.

❓ Go или Rust в 2026?
Go — для backend-сервисов, инфраструктуры, AI-агентов. Rust — для systems, embedded, perf-critical. Они не конкуренты. Учите Go, если цель — backend и быстро на работу.

❓ Нужна ли мат-база?
Для модулей 00–12 — нет. Для 14 (distributed) и 16 (system design) — желательно знать теорию вероятности и базовую алгоритмику.

❓ Сколько часов в день?
Минимум 1.5 часа в будни + 3–4 часа в выходные. Меньше — потеряете темп.

❓ Как искать первую работу?
После модуля 06 уже можно отправлять CV на Junior. После модуля 09 — на Middle. Главное — публичные проекты на GitHub и пет-проект, который вы можете объяснить в деталях.

❓ Что делать, если застрял?
Час борьбы → пять минут на решение из интернета → реализация заново без подглядывания. Если застрял на неделю — спроси в Gophers Slack или в @Golang_google чате.

PR'ы приветствуются: опечатки, новые бесплатные ресурсы на русском, уточнения по модулям. Открой issue, если нашёл устаревшую ссылку.

MIT — используй, форкай, улучшай.

⭐ Если roadmap помог — поставь звезду, это мотивирует развивать курс.

TEST ALGORITHMS SECTION