Senior Go Interview Prep

- Core Go: https://go.vbloher.org/docs/01-core-go/
- Механика defer в Go: https://go.vbloher.org/docs/01-core-go/defer/
- Встраивание структур и интерфейсов (Embedding): https://go.vbloher.org/docs/01-core-go/embedding/
- Ошибки в Go: error, wrapping, errors.Is/As/Join: https://go.vbloher.org/docs/01-core-go/errors/
- Дженерики в Go (1.18+): https://go.vbloher.org/docs/01-core-go/generics/
- Интерфейсы в Go: https://go.vbloher.org/docs/01-core-go/interfaces/
- Устройство map в Go: https://go.vbloher.org/docs/01-core-go/maps/
- panic / recover: механика, раскрутка стека и runtime-паники: https://go.vbloher.org/docs/01-core-go/panic-recover/
- Указатели в Go: https://go.vbloher.org/docs/01-core-go/pointers/
- Рефлексия в Go (reflect): https://go.vbloher.org/docs/01-core-go/reflection/
- Внутреннее устройство слайсов в Go: https://go.vbloher.org/docs/01-core-go/slices/
- Строки, руны и байты в Go: https://go.vbloher.org/docs/01-core-go/strings-runes-bytes/
- Система типов Go: defined types, alignment, memory layout: https://go.vbloher.org/docs/01-core-go/type-system/
- Concurrency: https://go.vbloher.org/docs/02-concurrency/
- sync/atomic: https://go.vbloher.org/docs/02-concurrency/atomic/
- Буферизованные vs небуферизованные каналы: https://go.vbloher.org/docs/02-concurrency/buffered-unbuffered/
- Канал vs Mutex: когда что выбрать: https://go.vbloher.org/docs/02-concurrency/channel-vs-mutex/
- Каналы: устройство hchan: https://go.vbloher.org/docs/02-concurrency/channels/
- Утечки горутин, дедлоки, livelock, starvation: https://go.vbloher.org/docs/02-concurrency/common-leaks-deadlocks/
- sync.Cond: https://go.vbloher.org/docs/02-concurrency/cond/
- context: https://go.vbloher.org/docs/02-concurrency/context/
- Горутины: жизненный цикл, стоимость, стек: https://go.vbloher.org/docs/02-concurrency/goroutines-lifecycle/
- sync.Mutex и sync.RWMutex: https://go.vbloher.org/docs/02-concurrency/mutex-rwmutex/
- sync.Once: https://go.vbloher.org/docs/02-concurrency/once/
- Паттерны конкурентности: https://go.vbloher.org/docs/02-concurrency/patterns/
- Race Detector (гонки данных и -race): https://go.vbloher.org/docs/02-concurrency/race-detector/
- Планировщик GMP: https://go.vbloher.org/docs/02-concurrency/scheduler-gmp/
- select: https://go.vbloher.org/docs/02-concurrency/select/
- sync.WaitGroup: https://go.vbloher.org/docs/02-concurrency/waitgroup/
- Runtime и память: https://go.vbloher.org/docs/03-runtime-memory/
- Паттерны аллокаций и снижение давления на GC: https://go.vbloher.org/docs/03-runtime-memory/allocation-patterns/
- Escape Analysis: когда переменная убегает в кучу: https://go.vbloher.org/docs/03-runtime-memory/escape-analysis/
- Сборщик мусора Go: concurrent tri-color mark-sweep: https://go.vbloher.org/docs/03-runtime-memory/gc/
- Тюнинг GC: GOGC и GOMEMLIMIT: https://go.vbloher.org/docs/03-runtime-memory/gogc-gomemlimit/
- GOMAXPROCS: параллелизм планировщика и проблема контейнеров: https://go.vbloher.org/docs/03-runtime-memory/gomaxprocs/
- Утечки горутин (goroutine leaks): https://go.vbloher.org/docs/03-runtime-memory/goroutine-leaks/
- Утечки памяти в Go (несмотря на GC): https://go.vbloher.org/docs/03-runtime-memory/memory-leaks/
- Модель памяти Go (Go Memory Model): happens-before и синхронизация: https://go.vbloher.org/docs/03-runtime-memory/memory-model/
- pprof: профилирование CPU, памяти и блокировок в Go: https://go.vbloher.org/docs/03-runtime-memory/pprof/
- Execution Tracer и runtime/trace: тайминги вместо агрегатов: https://go.vbloher.org/docs/03-runtime-memory/runtime-tracing/
- Стек vs Куча: где живут данные в Go: https://go.vbloher.org/docs/03-runtime-memory/stack-vs-heap/
- Тестирование: https://go.vbloher.org/docs/04-testing/
- testify, assert/require и golden files: https://go.vbloher.org/docs/04-testing/assertions-testify/
- Бенчмарки в Go: https://go.vbloher.org/docs/04-testing/benchmarks/
- Покрытие, -race и флаки-тесты: https://go.vbloher.org/docs/04-testing/coverage-race/
- Нативный fuzzing в Go (1.18+): https://go.vbloher.org/docs/04-testing/fuzzing/
- Интеграционные тесты, testcontainers-go, TestMain: https://go.vbloher.org/docs/04-testing/integration-testcontainers/
- Моки, стабы и тестируемость: https://go.vbloher.org/docs/04-testing/mocks/
- Table-driven тесты, subtests и параллельность: https://go.vbloher.org/docs/04-testing/table-driven/
- Backend: https://go.vbloher.org/docs/05-backend/
- Аутентификация и авторизация: AuthN/AuthZ, сессии vs токены, RBAC/ABAC, API keys, mTLS, секреты: https://go.vbloher.org/docs/05-backend/auth-authz/
- Graceful Shutdown HTTP/gRPC сервера в Go: https://go.vbloher.org/docs/05-backend/graceful-shutdown/
- gRPC: типы RPC, интерсепторы, контекст, метаданные, error model: https://go.vbloher.org/docs/05-backend/grpc/
- JWT (JSON Web Token): https://go.vbloher.org/docs/05-backend/jwt/
- Middleware-паттерн в Go: https://go.vbloher.org/docs/05-backend/middleware/
- net/http: Server, Handler, ServeMux, таймауты, Client и контекст: https://go.vbloher.org/docs/05-backend/net-http/
- OAuth2: роли, grant types, OIDC, токены и типовые ошибки: https://go.vbloher.org/docs/05-backend/oauth2/
- OpenAPI/Swagger, code generation, contract-first vs code-first, валидация: https://go.vbloher.org/docs/05-backend/openapi/
- Protocol Buffers: схемы, wire format, эволюция и совместимость: https://go.vbloher.org/docs/05-backend/protobuf/
- REST: принципы, версионирование, идемпотентность, статусы, пагинация, ошибки: https://go.vbloher.org/docs/05-backend/rest/
- Сети и протоколы: https://go.vbloher.org/docs/06-networking/
- Пулы соединений: http.Transport, БД, утечки: https://go.vbloher.org/docs/06-networking/connection-pooling/
- DNS: записи, резолвинг, кэширование, DNS в Go: https://go.vbloher.org/docs/06-networking/dns/
- Версии HTTP: 1.1, 2, 3: https://go.vbloher.org/docs/06-networking/http-versions/
- TCP/IP: модель, транспорт и что важно бэкендеру: https://go.vbloher.org/docs/06-networking/tcp-ip/
- TLS: handshake, сертификаты, mTLS, производительность: https://go.vbloher.org/docs/06-networking/tls/
- UDP и надёжность поверх UDP: https://go.vbloher.org/docs/06-networking/udp/
- WebSocket: upgrade, фреймы, масштабирование: https://go.vbloher.org/docs/06-networking/websocket/
- Базы данных: https://go.vbloher.org/docs/07-databases/
- Пул соединений к PostgreSQL в Go: database/sql, pgx, pgxpool, PgBouncer: https://go.vbloher.org/docs/07-databases/connection-pooling-pgx/
- Взаимоблокировки (Deadlocks) в PostgreSQL: https://go.vbloher.org/docs/07-databases/deadlocks/
- Индексы в PostgreSQL: https://go.vbloher.org/docs/07-databases/indexes/
- Уровни изоляции транзакций в PostgreSQL: https://go.vbloher.org/docs/07-databases/isolation-levels/
- MVCC в PostgreSQL: версии строк, видимость, VACUUM и bloat: https://go.vbloher.org/docs/07-databases/mvcc/
- Обзор NoSQL и Redis: https://go.vbloher.org/docs/07-databases/nosql-redis/
- Партиционирование таблиц в PostgreSQL: https://go.vbloher.org/docs/07-databases/partitioning/
- Архитектура PostgreSQL: https://go.vbloher.org/docs/07-databases/postgresql-architecture/
- Планирование и оптимизация запросов в PostgreSQL: https://go.vbloher.org/docs/07-databases/query-planning/
- Репликация в PostgreSQL: https://go.vbloher.org/docs/07-databases/replication/
- Шардирование (горизонтальное масштабирование): https://go.vbloher.org/docs/07-databases/sharding/
- Транзакции в PostgreSQL и Go (database/sql, pgx): https://go.vbloher.org/docs/07-databases/transactions/
- Распределённые системы: https://go.vbloher.org/docs/08-distributed-systems/
- CAP теорема: https://go.vbloher.org/docs/08-distributed-systems/cap-theorem/
- Circuit Breaker: https://go.vbloher.org/docs/08-distributed-systems/circuit-breaker/
- Консенсус и Raft: репликация состояния в присутствии отказов: https://go.vbloher.org/docs/08-distributed-systems/consensus-raft/
- Модели согласованности: https://go.vbloher.org/docs/08-distributed-systems/consistency/
- Гарантии доставки сообщений: at-most-once / at-least-once / exactly-once: https://go.vbloher.org/docs/08-distributed-systems/delivery-guarantees/
- Eventual Consistency: https://go.vbloher.org/docs/08-distributed-systems/eventual-consistency/
- Идемпотентность в распределённых системах: https://go.vbloher.org/docs/08-distributed-systems/idempotency/
- Apache Kafka: https://go.vbloher.org/docs/08-distributed-systems/kafka/
- Transactional Outbox: https://go.vbloher.org/docs/08-distributed-systems/outbox/
- RabbitMQ: AMQP 0-9-1, маршрутизация, надёжность доставки и сравнение с Kafka: https://go.vbloher.org/docs/08-distributed-systems/rabbitmq/
- Ретраи: backoff, jitter, budgets и идемпотентность: https://go.vbloher.org/docs/08-distributed-systems/retries/
- Saga Pattern: https://go.vbloher.org/docs/08-distributed-systems/saga/
- Observability: https://go.vbloher.org/docs/09-observability/
- Grafana: https://go.vbloher.org/docs/09-observability/grafana/
- Метрики: RED, USE, Golden Signals: https://go.vbloher.org/docs/09-observability/metrics/
- OpenTelemetry: https://go.vbloher.org/docs/09-observability/opentelemetry/
- Prometheus: https://go.vbloher.org/docs/09-observability/prometheus/
- SLI / SLO / SLA: https://go.vbloher.org/docs/09-observability/slo-sli/
- Структурированное логирование (slog): https://go.vbloher.org/docs/09-observability/structured-logging/
- Distributed Tracing: https://go.vbloher.org/docs/09-observability/tracing/
- System Design: https://go.vbloher.org/docs/10-system-design/
- Analytics Pipeline: https://go.vbloher.org/docs/10-system-design/analytics-pipeline/
- Chat System: https://go.vbloher.org/docs/10-system-design/chat/
- Фреймворк System Design интервью: https://go.vbloher.org/docs/10-system-design/framework/
- Notification Service: https://go.vbloher.org/docs/10-system-design/notification-service/
- Order Service: https://go.vbloher.org/docs/10-system-design/order-service/
- Payment Service: https://go.vbloher.org/docs/10-system-design/payment-service/
- Rate Limiter: https://go.vbloher.org/docs/10-system-design/rate-limiter/
- URL Shortener: https://go.vbloher.org/docs/10-system-design/url-shortener/
- DevOps: https://go.vbloher.org/docs/11-devops/
- CI/CD: пайплайны, стадии, стратегии деплоя: https://go.vbloher.org/docs/11-devops/cicd/
- Облака (AWS / GCP) для бэкендера: https://go.vbloher.org/docs/11-devops/cloud-aws-gcp/
- Docker для Go-разработчика: https://go.vbloher.org/docs/11-devops/docker/
- GitHub Actions и GitLab CI: https://go.vbloher.org/docs/11-devops/github-gitlab-ci/
- Kubernetes для Go-разработчика: https://go.vbloher.org/docs/11-devops/kubernetes/
- Terraform / Infrastructure as Code: https://go.vbloher.org/docs/11-devops/terraform/
- Алгоритмы: https://go.vbloher.org/docs/12-algorithms/
- Типовые алгоритмические задачи и паттерны: https://go.vbloher.org/docs/12-algorithms/common-problems/
- Асимптотическая сложность (Big-O): https://go.vbloher.org/docs/12-algorithms/complexity/
- Структуры данных в Go: https://go.vbloher.org/docs/12-algorithms/data-structures/
- Специфика live-coding на Go: https://go.vbloher.org/docs/12-algorithms/go-specifics/
- Behavioral: https://go.vbloher.org/docs/13-behavioral/
- Конфликты, разногласия и работа со стейкхолдерами: https://go.vbloher.org/docs/13-behavioral/conflicts/
- Как проходит senior-интервью: этапы, оценка, оффер: https://go.vbloher.org/docs/13-behavioral/interview-flow/
- Лидерство и менторство: https://go.vbloher.org/docs/13-behavioral/leadership-mentoring/
- Типовые поведенческие вопросы для Senior: https://go.vbloher.org/docs/13-behavioral/senior-questions/


> Модуль: Concurrency · Уровень: Middle+/Senior

## TL;DR
`WaitGroup` — счётчик незавершённой работы: `Add(n)` увеличивает, `Done` уменьшает, `Wait` блокирует, пока счётчик не дойдёт до нуля. Главное правило: **`Add` вызывать до запуска горутины** (в той же горутине, что и `Wait`), а не внутри неё, иначе возможна гонка между `Wait` и стартом. Go 1.25 добавил `WaitGroup.Go`, который атомарно делает `Add(1)` + запуск + `Done`, устраняя самую частую ошибку.

## Теория

### Контракт
```go
var wg sync.WaitGroup
for _, task := range tasks {
    wg.Add(1)              // ДО go
    go func(t Task) {
        defer wg.Done()    // гарантированно даже при панике
        process(t)
    }(task)
}
wg.Wait()                  // блокируемся, пока счётчик != 0
```

- `Add(delta)` — атомарно прибавляет delta (может быть отрицательным) к счётчику.
- `Done()` — это `Add(-1)`.
- `Wait()` — блокирует, пока счётчик не станет 0. Если уже 0 — возвращается сразу.
- Если счётчик становится **отрицательным** → паника `sync: negative WaitGroup counter`.

### Устройство под капотом
До Go 1.20 WaitGroup хранил счётчик и число ожидающих в одном 64-битном слове (с трюками выравнивания для 32-бит платформ). С Go 1.25 (рефакторинг под `WaitGroup.Go`) внутреннее представление изменилось, но логически — это:

```go
type WaitGroup struct {
    state atomic.Uint64 // старшие 32 бита: counter, младшие 32: waiters
    sema  uint32        // семафор для парковки ожидающих в Wait
}
```

- `Add` атомарно меняет старшую половину (counter).
- Когда counter доходит до 0 и есть waiters>0, `Add` будит всех ожидающих через `runtime_Semrelease` по `sema`.
- `Wait` атомарно инкрементит waiters и паркуется на семафоре (`runtime_Semacquire`).

Гонка возникает, если `Add` для следующей порции делается **после** того, как counter уже упал до 0 и `Wait` проснулся — поведение становится неопределённым.

### Go 1.25: WaitGroup.Go
```go
var wg sync.WaitGroup
for _, task := range tasks {
    wg.Go(func() {          // Add(1) + go + Done() внутри
        process(task)        // loopvar в 1.22+ безопасен
    })
}
wg.Wait()
```
`Go` инкапсулирует `Add(1)`, запуск горутины и `defer Done()`. Это убирает целый класс ошибок: забытый `Done`, `Add` в неправильном месте, рассинхрон Add/Done. Совмещён с loopvar semantics (Go 1.22, каждая итерация — своя переменная), поэтому замыкание над `task` безопасно.

### Переиспользование
WaitGroup можно использовать повторно: после того как `Wait` вернулся (counter=0), можно снова делать `Add`. Но **нельзя** вызывать `Add` с положительным delta одновременно с активным `Wait`, который ещё может ждать предыдущую волну. Безопасный паттерн — волнами: `Add → go → Wait`, потом следующая волна.

## Подводные камни / gotchas
- **`Add(1)` внутри горутины** — классическая гонка:
  ```go
  // НЕПРАВИЛЬНО
  for _, t := range tasks {
      go func(t Task) {
          wg.Add(1)        // может выполниться ПОСЛЕ wg.Wait()
          defer wg.Done()
          process(t)
      }(t)
  }
  wg.Wait()                // может увидеть счётчик 0 и выйти раньше времени
  ```
  `Wait` может вернуться до того, как горутины успеют сделать Add → программа решит, что всё готово, хотя работа не началась. `-race` обычно это ловит.
- **Забыли `Done`** → `Wait` висит вечно (deadlock/leak). Всегда `defer wg.Done()` первой строкой.
- **Лишний `Done`** или Add с большим отрицательным delta → паника negative counter.
- **Копирование WaitGroup** после использования запрещено (`copylocks`/go vet). Передавайте по указателю.
- **Сбор результатов:** WaitGroup только синхронизирует завершение, не передаёт данные. Для результатов нужен канал/слайс с индексами/`errgroup`. Запись разных горутин в разные индексы слайса безопасна без мьютекса (разные ячейки), но `append` из нескольких горутин — гонка.
- **WaitGroup не отменяет** работу. Для отмены нужен `context`. Для «дождаться + собрать ошибку + отменить остальных» используйте `errgroup.Group`.
- **`Wait` без последующего использования результата** — не гарантирует видимость записей, сделанных в горутинах? Гарантирует: `Done` (release) happens-before возврат `Wait` (acquire), поэтому записи до Done видны после Wait.

## Вопросы на собеседовании

**В:** Почему `Add` нужно вызывать до `go`, а не внутри горутины?
**О:** `Wait` смотрит на счётчик. Если `Add` делается внутри горутины, планировщик может ещё не запустить её к моменту `Wait` — счётчик будет 0, `Wait` вернётся преждевременно. Это гонка, ловится `-race`. `Add` должен выполниться в горутине, вызывающей `Wait`, до старта рабочих.

**В:** Что происходит при отрицательном счётчике?
**О:** Паника `sync: negative WaitGroup counter`. Бывает при лишнем `Done` или несбалансированных Add/Done. Паника осознанная — это симптом сломанной синхронизации.

**В:** Гарантирует ли WaitGroup видимость памяти?
**О:** Да. `Done` (как Add) образует release, возврат из `Wait` — acquire. Записи, сделанные горутиной до `Done`, видны коду после `Wait` (happens-before). Поэтому можно безопасно читать результаты, записанные горутинами, после Wait.

**В:** Можно ли переиспользовать WaitGroup?
**О:** Да, после возврата `Wait` (счётчик 0) можно снова Add. Но нельзя добавлять положительный delta параллельно с Wait, который ещё ждёт текущую волну. Работайте волнами Add→Wait.

**В:** Что даёт `WaitGroup.Go` в Go 1.25?
**О:** Атомарно делает `Add(1)`, запускает переданную функцию в горутине и гарантирует `Done` через defer. Устраняет частые ошибки: забытый Done, Add не в том месте. Хорошо сочетается с per-iteration loopvar (1.22).

**В:** Как собрать результаты/ошибки горутин?
**О:** WaitGroup не передаёт данные. Пишите в предвыделенный слайс по индексам (разные ячейки — без гонки) или в канал. Для ошибок и отмены — `golang.org/x/sync/errgroup`.

**В:** В чём разница WaitGroup и закрытия канала для сигнала завершения?
**О:** WaitGroup — «дождаться N завершений». Закрытие канала — «broadcast одного события всем читателям». WaitGroup считает работу, канал сигнализирует. Часто комбинируются: горутины ждут `<-done`, основной ждёт `wg.Wait()`.

**В:** Почему нельзя копировать WaitGroup?
**О:** Внутри атомарное слово состояния и семафор. Копия — это второй независимый счётчик; синхронизация рассинхронизируется. `go vet` ловит копирование.

## На что копают на senior+
- Внутреннее представление: упаковка counter+waiters в одно атомарное слово, выравнивание для 32-бит ARM/x86 (исторический `state1 [3]uint32`).
- Happens-before гарантии WaitGroup и где они в memory model Go.
- Почему `WaitGroup.Go` появился именно с loopvar-семантикой и как он взаимодействует с panic propagation.
- Сравнение с `errgroup`: лимит параллелизма (`SetLimit`), первый ошибочный результат, отмена контекста.
- Гонка Add-после-Wait: как именно она детектируется в `-race` (отслеживание состояния WaitGroup рантаймом в race-режиме).