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/


> Модуль: Тестирование · Уровень: Middle+/Senior

## TL;DR
`testify` — самая популярная вспомогательная библиотека: `assert` (помечает fail и **продолжает** тест) и `require` (помечает fail и **немедленно останавливает** через `t.FailNow`). Используйте `require` для предусловий, без которых дальнейшие проверки бессмысленны/опасны (nil-разыменование), и `assert` для независимых проверок, где хочется увидеть все падения сразу. Стандартной библиотеки (`if got != want { t.Errorf(...) }`) часто достаточно — для простых сравнений она читаема и без зависимостей; testify окупается на множестве проверок и понятных дифф-сообщениях. Для больших/структурных выходов — **golden files**: эталон в `testdata/*.golden`, обновляемый флагом `-update`, сравнение через `go-cmp`.

## Теория

### assert vs require
```go
import (
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
)

func TestUser(t *testing.T) {
    u, err := repo.Get(ctx, 42)
    require.NoError(t, err)   // если err != nil — дальше идти нельзя, FailNow
    require.NotNil(t, u)      // защищаем от nil-разыменования ниже

    assert.Equal(t, "alice", u.Name)  // независимые проверки —
    assert.Equal(t, 42, u.ID)         // увидим оба падения за один прогон
    assert.True(t, u.Active)
}
```
- **`require.*`** при провале вызывает `t.FailNow()` — останавливает текущую горутину теста. Применять, когда продолжение не имеет смысла или приведёт к панике (после получения err проверяем `NoError`, перед разыменованием — `NotNil`).
- **`assert.*`** при провале вызывает `t.Fail()` — тест помечен проваленным, но выполняется дальше. Применять для группы независимых проверок, чтобы получить полную картину за один запуск.

**Важно:** `require` нельзя вызывать из не-тестовой горутины (как и `t.FailNow`) — `FailNow` делает `runtime.Goexit`, завершая только свою горутину. В горутинах используйте `assert` + синхронизацию и проверку в основной горутине.

### Полезные функции testify
```go
assert.Equal(t, want, got)            // глубокое сравнение (ObjectsAreEqual)
assert.EqualValues(t, want, got)      // с приведением типов (int32 vs int64)
assert.ElementsMatch(t, a, b)         // равны как мультимножества (порядок не важен)
require.ErrorIs(t, err, ErrNotFound)  // errors.Is
require.ErrorAs(t, err, &target)      // errors.As
assert.ErrorContains(t, err, "denied")
assert.Eventually(t, cond, 2*time.Second, 50*time.Millisecond) // polling для асинхронного
assert.Panics(t, func(){ ... })
assert.InDelta(t, 1.0, x, 0.01)       // флоаты с допуском
assert.JSONEq(t, `{"a":1}`, body)     // семантическое сравнение JSON
```
`assert.Equal(t, expected, actual)` — порядок аргументов важен для читаемости дифф-сообщения (expected первым).

### Когда стандартной библиотеки достаточно
```go
func TestAdd(t *testing.T) {
    if got := Add(2, 3); got != 5 {
        t.Errorf("Add(2,3) = %d, want 5", got)
    }
}
```
Стандартный подход выигрывает, когда:
- сравнение простое (скаляры, строки),
- проект сознательно избегает внешних зависимостей (стандарт в Go-сообществе и в самом Go SDK — testify не используется в исходниках Go),
- нужен полный контроль над сообщением об ошибке.

Для сложных структур стандарт комбинируют с `go-cmp`:
```go
if diff := cmp.Diff(want, got); diff != "" {
    t.Errorf("mismatch (-want +got):\n%s", diff)
}
```
`cmp.Diff` даёт читаемый дифф, поддерживает опции (`cmpopts.IgnoreFields`, `cmpopts.EquateApprox`, кастомные `Equal`), безопасен на неэкспортируемых полях (с опцией) — часто это лучше, чем `assert.Equal` для глубоких структур.

**Позиция многих senior-инженеров:** testify удобен и широко распространён, но добавляет зависимость и свой DSL; для библиотек предпочтительнее стандарт + go-cmp, для прикладных сервисов testify часто оправдан скоростью написания. Знание обоих и trade-off важнее догмы.

### Golden files
Эталонный вывод хранится в файле; тест сравнивает фактический вывод с ним. Подходит для больших/структурных артефактов: сгенерированный код, HTML/JSON-рендеры, форматтеры, отчёты.
```go
var update = flag.Bool("update", false, "update golden files")

func TestRender(t *testing.T) {
    got := Render(input)

    golden := filepath.Join("testdata", t.Name()+".golden")
    if *update {
        require.NoError(t, os.WriteFile(golden, []byte(got), 0o644))
    }
    want, err := os.ReadFile(golden)
    require.NoError(t, err)

    if diff := cmp.Diff(string(want), got); diff != "" {
        t.Errorf("golden mismatch (-want +got):\n%s", diff)
    }
}
```
Обновление: `go test -run TestRender -update`. Затем эталон ревьюится в diff и коммитится.

Достоинства: легко поддерживать большие ожидаемые выходы, изменения видны в code review как diff golden-файла. Риски: бездумный `-update` коммитит регрессию как «новый эталон» — golden-файлы обязаны ревьюиться человеком; нестабильный вывод (таймстемпы, мапы с рандомным порядком, указатели) делает golden флаки — нормализуйте перед сравнением (сортировка ключей, замена времени плейсхолдером). `testdata` — специальное имя: `go test` игнорирует эту директорию при сборке.

## Подводные камни / gotchas
- **Путаница assert/require.** `assert.NoError` не остановит тест — следующая строка разыменует nil и упадёт паникой с непонятным стеком. Перед разыменованием — `require`.
- **`require` из горутины** — `FailNow`/`Goexit` завершит только горутину, тест продолжится в неопределённом состоянии. В горутинах — `assert` + сбор результатов.
- **Порядок аргументов `Equal(t, expected, actual)`** перепутан → дифф «-want +got» вводит в заблуждение.
- **`assert.Equal` на функциях/каналах/несравнимых** и на типах с указателями внутри даёт неинтуитивные результаты; для сложных структур надёжнее `cmp.Diff` с опциями.
- **`assert.Equal` различает типы:** `int(1) != int64(1)`. Нужен `EqualValues` или приведение.
- **Golden без ревью.** `-update` без вдумчивого diff закрепляет баг. Golden-файлы — часть code review.
- **Нестабильный golden:** время, рандомизированный порядок мап, абсолютные пути, указатели. Нормализуйте вывод детерминированным.
- **Зависимость ради ассертов.** Для библиотеки добавление testify в `go.mod` навязывает зависимость потребителям тестов — взвешивайте.
- **`assert.Error`/`NoError` без проверки конкретной ошибки** маскирует «не ту» ошибку. Используйте `ErrorIs`/`ErrorAs`.

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

**В:** В чём разница между `assert` и `require` в testify?
**О:** `assert` помечает тест проваленным (`t.Fail`) и продолжает выполнение — годится для независимых проверок, чтобы увидеть все падения. `require` вызывает `t.FailNow` и немедленно прекращает тест — для предусловий, без которых дальше идти нельзя (после получения ошибки, перед разыменованием nil).

**В:** Можно ли использовать `require` внутри горутины?
**О:** Нет. `require` вызывает `FailNow`, который делает `runtime.Goexit` и завершает только текущую горутину, оставляя тест в неопределённом состоянии. В горутинах используют `assert` и собирают результаты, проверяя их в основной горутине теста.

**В:** Когда стандартной библиотеки достаточно и зачем тогда testify?
**О:** Для простых сравнений скаляров/строк `if got != want { t.Errorf }` читаем и без зависимостей — так пишут в самом Go SDK. testify окупается на множестве проверок, даёт лаконичный API и понятные дифф-сообщения, `ErrorIs`/`ErrorAs`/`Eventually`. Для глубоких структур многие предпочитают стандарт + `go-cmp.Diff`.

**В:** Что такое golden files и когда они уместны?
**О:** Эталонный вывод в `testdata/*.golden`, с которым сравнивается фактический результат; обновляется флагом `-update`. Уместны для больших/структурных артефактов (генерация кода, рендеры, форматтеры), где изменения удобно ревьюить как diff. Требуют детерминированного вывода и обязательного ревью при обновлении.

**В:** Чем `cmp.Diff` лучше `assert.Equal` для структур?
**О:** Даёт человекочитаемый дифф (что именно отличается), поддерживает опции (игнор полей, допуск для флоатов, кастомный Equal, обработка неэкспортируемых полей), и явно паникует на несравнимом, заставляя задать опцию. `assert.Equal` для глубоких структур даёт менее наглядное сообщение.

**В:** Почему `assert.Equal(t, int32(1), int64(1))` падает?
**О:** testify сравнивает и значение, и тип через рефлексию; разные числовые типы не равны. Нужно `assert.EqualValues` (приводит типы) или явное приведение к одному типу.

**В:** Главный риск golden files и как его снизить?
**О:** Бездумный `-update` закрепляет регрессию как новый эталон. Снижают обязательным ревью diff golden-файлов в PR и нормализацией нестабильных частей вывода (время, порядок ключей мап, пути), чтобы тест не был флаки.

## На что копают на senior+
- **Осознанный выбор:** trade-off testify vs стандарт+go-cmp, отказ от зависимостей в библиотеках, единообразие в проекте.
- **Семантика fail:** Fail vs FailNow, поведение в горутинах, корректная обработка ошибок (`ErrorIs/As` вместо «просто была ошибка»).
- **Сравнение значений:** go-cmp опции, кастомные Equal, обращение с неэкспортируемыми полями, временами, протобуфами, флоатами.
- **Golden-дисциплина:** детерминизм вывода, нормализация, ревью эталонов, защита от «обновил и закоммитил баг».
- **Качество сообщений:** информативность ассертов для быстрой диагностики, `t.Helper()` в кастомных хелперах для правильного указания строки падения.