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 · Уровень: Senior

## TL;DR
`context.Context` переносит сигнал отмены, дедлайн и request-scoped значения сквозь границы вызовов и горутин. Корни — `Background()`/`TODO()`; производные — `WithCancel`/`WithTimeout`/`WithDeadline`/`WithValue`. Отмена распространяется по дереву контекстов вниз; всегда вызывайте `cancel()` (обычно через `defer`), чтобы не текли ресурсы.

## Теория

### Иерархия и корни
- `context.Background()` — пустой корень для main, init, тестов; никогда не отменяется.
- `context.TODO()` — заглушка, когда непонятно, какой контекст передать; семантически = Background, но сигнализирует «надо доделать».
- Производные образуют **дерево**: отмена/дедлайн родителя каскадно отменяет детей.

```go
ctx, cancel := context.WithCancel(parent)
defer cancel() // ОБЯЗАТЕЛЬНО: освобождает горутину/таймер и удаляет из дерева

ctx, cancel := context.WithTimeout(parent, 2*time.Second)
defer cancel()

ctx, cancel := context.WithDeadline(parent, time.Now().Add(time.Second))
defer cancel()

ctx := context.WithValue(parent, key, val) // без cancel
```

### Интерфейс
```go
type Context interface {
    Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}      // закрывается при отмене/дедлайне
    Err() error                 // nil | Canceled | DeadlineExceeded
    Value(key any) any
}
```
`Done()` возвращает канал, который **закрывается** (broadcast) при отмене. `Err()` после закрытия даёт причину: `context.Canceled` или `context.DeadlineExceeded`.

### Под капотом
- `cancelCtx` хранит `done` (lazily созданный канал), `children map[canceler]struct{}`, `err`. `cancel()` закрывает `done`, проставляет `err`, рекурсивно отменяет детей и **отсоединяет себя от родителя** (`removeChild`), чтобы не было утечки в дереве.
- `timerCtx` — это `cancelCtx` + `time.Timer`, который вызовет `cancel(DeadlineExceeded)` по дедлайну.
- `valueCtx` — связный список: `Value(key)` идёт вверх по цепочке родителей, сравнивая ключи. O(глубины), поэтому много значений — антипаттерн.
- **Propagation отмены**: при создании дочернего `cancelCtx` рантайм проверяет, отменяем ли родитель; если да — регистрируется в `children`, иначе при необходимости запускает горутину `propagateCancel`, слушающую `parent.Done()`.

### Распространение
Контекст передают **первым аргументом** `ctx context.Context` во все функции, делающие I/O, RPC, долгую работу. Каждая горутина в дереве запроса получает (производный) ctx и обязана реагировать на `ctx.Done()`.

```go
func handle(ctx context.Context) error {
    ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
    defer cancel()
    return callRPC(ctx)
}

func worker(ctx context.Context, in <-chan Job) {
    for {
        select {
        case <-ctx.Done():
            return // отмена / дедлайн / завершение
        case job := <-in:
            process(ctx, job)
        }
    }
}
```

### Значения (WithValue) — best practices
- Только **request-scoped** данные: trace/request ID, аутентификация, дедлайны логирования. Не для передачи опциональных параметров функции.
- Ключ — **неэкспортируемый тип**, чтобы избежать коллизий:
```go
type ctxKey int
const userKey ctxKey = 0
ctx = context.WithValue(ctx, userKey, user)
u, ok := ctx.Value(userKey).(*User)
```

### Go 1.21+: WithoutCancel, AfterFunc, WithDeadlineCause, Cause
- `context.WithoutCancel(ctx)` — наследует значения, но игнорирует отмену родителя (для фоновых задач, переживающих запрос).
- `context.AfterFunc(ctx, f)` — вызывает `f` в своей горутине при отмене ctx; возвращает stop-функцию.
- `context.WithTimeoutCause`/`WithDeadlineCause` + `context.Cause(ctx)` — даёт явную причину отмены вместо общего `DeadlineExceeded`.
- `context.WithCancelCause` — `cancel(err)` с произвольной причиной, доступной через `Cause`.

## Подводные камни / gotchas
- **Не вызвали `cancel()`** → утечка: для `WithCancel` остаётся регистрация в дереве/горутина propagate; для `WithTimeout` — живой таймер до дедлайна. `go vet` ловит часть случаев (`lostcancel`).
- **Хранение Context в структуре** — антипаттерн (кроме явных исключений). Передавайте как аргумент.
- **`context.WithValue` для бизнес-параметров** — типонебезопасно и непрозрачно; используйте явные аргументы.
- **Строковые/встроенные ключи** в WithValue → коллизии между пакетами. Только приватные типы.
- **Игнорирование `ctx.Done()`** в долгой работе делает отмену бесполезной — операция всё равно доработает до конца.
- **Передача `nil` Context** — паника/UB; используйте `TODO()`.
- **`ctx.Err()` без проверки Done** в редких случаях гонко: правильно — читать после получения из `Done()` либо доверять `select`.
- **Дедлайн короче родительского** работает; длиннее — игнорируется (родительский дедлайн всё равно отменит раньше).

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

**В:** Зачем нужен context?
**О:** Для сквозной передачи сигнала отмены, дедлайна и request-scoped значений через границы горутин и вызовов. Это стандартный способ скоординированно завершать дерево операций (RPC, БД, фоновые задачи) при таймауте, отмене клиентом или shutdown.

**В:** Разница Background и TODO?
**О:** Семантически идентичны (пустой неотменяемый корень). `Background` — для входных точек (main, тесты, верх стека); `TODO` — маркер «контекст ещё не проброшен/неясен», помогает статическому анализу и ревью.

**В:** Что возвращает `Done()` и когда срабатывает?
**О:** Канал `<-chan struct{}`, который закрывается при отмене или дедлайне (broadcast всем слушателям). После закрытия `Err()` возвращает `Canceled` или `DeadlineExceeded`.

**В:** Почему обязательно вызывать cancel?
**О:** `cancel` закрывает done, отменяет детей и отвязывает контекст от родителя; для timer-контекстов останавливает таймер. Без него — утечка горутины/таймера и рост дерева контекстов. `go vet` предупреждает о потерянном cancel.

**В:** Как распространяется отмена по дереву?
**О:** При отмене узла закрывается его `done`, затем рекурсивно отменяются все зарегистрированные дети. Дочерний cancelCtx либо регистрируется напрямую в родителе, либо (если родитель не «родной» cancelCtx) обслуживается горутиной propagateCancel, слушающей `parent.Done()`.

**В:** Как правильно класть значения?
**О:** Только request-scoped данные, с приватным типом ключа, чтобы исключить коллизии. Не использовать для передачи обычных аргументов. Доступ — type assertion с проверкой `ok`. Помнить про O(глубины) при чтении.

**В:** Как сделать фоновую задачу, переживающую запрос?
**О:** `context.WithoutCancel(ctx)` сохранит значения (trace id и т.п.), но отвяжет от отмены родителя; либо новый `Background()` с переносом нужных значений. Для запуска кода по отмене — `context.AfterFunc`.

**В:** Чем отличается Canceled от DeadlineExceeded и что такое Cause?
**О:** `Canceled` — явный вызов cancel; `DeadlineExceeded` — истёк дедлайн. С 1.21 `WithCancelCause`/`WithTimeoutCause` позволяют задать произвольную причину, читаемую `context.Cause(ctx)`, при этом `Err()` остаётся стандартным.

## На что копают на senior+
- Устройство `cancelCtx`/`timerCtx`/`valueCtx`, lazy-создание `done`, `removeChild` и почему это предотвращает утечку дерева.
- `propagateCancel`: когда запускается отдельная горутина-наблюдатель и её стоимость.
- Семантика `Cause`/`WithoutCancel`/`AfterFunc` (1.21) и их применение.
- Корректная обработка отмены в библиотечном коде (не «глотать» ctx.Err, прокидывать дедлайн в нижележащие вызовы).
- Взаимодействие context с `errgroup`, `http.Server` shutdown, database/sql (ctx в каждом запросе).
- Почему хранение ctx в структуре ломает контракт и когда это всё же допустимо (например, в `http.Request`).