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
- **HTTP/1.1**: текстовый, одно соединение = один запрос в момент времени; keep-alive переиспользует соединение; pipelining почти не работает (HoL blocking); параллелизм достигается множеством TCP-соединений (браузеры ~6 на хост).
- **HTTP/2**: бинарный, мультиплексирование множества потоков по одному TCP, сжатие заголовков (HPACK), приоритеты, server push (по факту устарел). Решает HoL на уровне приложения, но НЕ на уровне TCP.
- **HTTP/3**: HTTP поверх QUIC (UDP+TLS1.3). Убирает HoL на транспорте, быстрый handshake, миграция соединения.
- Бэкендеру: gRPC требует HTTP/2; Go `net/http` сервер и клиент поддерживают h2 автоматически по TLS+ALPN; HTTP/3 — через `quic-go`/`http3`.

## Теория

### HTTP/1.1
- **Текстовый протокол**, человекочитаемый, парсится построчно.
- **Persistent connections (keep-alive)** — дефолт в 1.1: соединение не закрывается после ответа, переиспользуется. Управляется `Connection: keep-alive`/`close` и таймаутами.
- **Pipelining**: можно отправить несколько запросов, не дожидаясь ответов, НО ответы должны прийти строго по порядку → **head-of-line blocking**: медленный первый ответ блокирует остальные. На практике pipelining отключён почти везде (баги прокси).
- **Параллелизм**: реальная конкурентность достигается открытием нескольких TCP-соединений (браузеры ~6 на origin). Отсюда хаки вроде domain sharding.
- Один запрос/ответ в момент времени на соединение → накладные расходы и затраты на handshake.

### HTTP/2
Бинарный протокол поверх одного TCP-соединения (обычно поверх TLS, ALPN `h2`):
- **Бинарное фреймирование**: всё разбито на фреймы (HEADERS, DATA, SETTINGS, WINDOW_UPDATE, RST_STREAM, PING, GOAWAY...).
- **Мультиплексирование**: множество **streams** в одном соединении, каждый со своим ID; запросы/ответы чередуются фреймами → нет HoL на уровне приложения, одно соединение вместо шести.
- **HPACK**: сжатие заголовков — статическая + динамическая таблица + Huffman. Сильно экономит на повторяющихся заголовках (Cookie, User-Agent). Защищён от CRIME-атаки (в отличие от gzip-сжатия заголовков).
- **Flow control** на уровне streams и соединения (WINDOW_UPDATE) — независимо от TCP-окна.
- **Приоритеты/зависимости** streams (дерево приоритетов; в реальности реализовано непоследовательно, в RFC 9113 deprecated в пользу нового механизма).
- **Server push**: сервер мог инициативно слать ресурсы. По факту **выпилен** (Chrome убрал поддержку) — плохо взаимодействовал с кэшем; вместо него `103 Early Hints`.
- **Ограничение**: TCP HoL blocking остаётся. Потеря одного TCP-сегмента блокирует ВСЕ streams, потому что TCP доставляет байты по порядку. Это и решает HTTP/3.

### HTTP/3
HTTP поверх **QUIC** (UDP + TLS 1.3):
- **Нет TCP HoL**: streams в QUIC независимы; потеря пакета в одном stream не блокирует другие.
- **Быстрый handshake**: TLS 1.3 встроен в QUIC, 1-RTT (или 0-RTT на повторных).
- **Connection migration**: соединение живёт через Connection ID, переживает смену IP (Wi-Fi↔LTE).
- **QPACK** вместо HPACK (адаптация сжатия заголовков под отсутствие гарантированного порядка между streams).
- **Деплой**: обычно сервер анонсирует поддержку через заголовок `Alt-Svc: h3=":443"`, клиент переключается на h3.

### Сравнение
| | HTTP/1.1 | HTTP/2 | HTTP/3 |
|---|---|---|---|
| Транспорт | TCP | TCP | QUIC/UDP |
| Формат | текст | бинарный | бинарный |
| Мультиплексирование | нет (только pipelining, HoL) | да (streams) | да (streams) |
| HoL приложения | да | нет | нет |
| HoL транспорта (TCP) | да | да | нет |
| Сжатие заголовков | нет | HPACK | QPACK |
| Handshake | TCP(+TLS) | TCP+TLS | QUIC (TLS1.3 встроен), 0/1-RTT |
| Connection migration | нет | нет | да |
| Server push | нет | да (устарел) | да (редко) |
| TLS обязателен | нет | де-факто да | да |

### Go и версии HTTP
```go
// HTTP/2 включается автоматически на TLS-сервере (ALPN h2),
// если используется http.Server с TLS и не отключён.
srv := &http.Server{Addr: ":443", Handler: mux}
srv.ListenAndServeTLS("cert.pem", "key.pem") // h2 + h1 через ALPN

// Клиент: http.Transport также сам согласует h2 по TLS+ALPN.
// h2c (HTTP/2 без TLS, cleartext) НЕ включается автоматически —
// нужен golang.org/x/net/http2 + http2.ConfigureServer/h2c.Handler.
```
```go
// HTTP/3 (вне stdlib): github.com/quic-go/quic-go/http3
client := &http.Client{Transport: &http3.Transport{}}
resp, _ := client.Get("https://example.com")
```
- gRPC всегда поверх HTTP/2 (нужны streams для bidi-стриминга).
- Go-сервер автоматически отдаёт и h1, и h2 по одному TLS-листенеру (ALPN решает).

## Подводные камни / gotchas
- **HTTP/2 не убирает TCP HoL**: при потерях на лоссистой сети один TCP-коннект с h2 может быть ХУЖЕ нескольких h1-соединений. Это контринтуитивно.
- **h2c (cleartext h2)** требует явной настройки в Go — по plain TCP h2 сам не включится.
- **Server push мёртв** — не предлагайте его как оптимизацию; правильный ответ `103 Early Hints` / preload.
- **HPACK динамическая таблица** — общее состояние соединения; неправильная реализация прокси может ломаться при больших заголовках; есть лимиты (`SETTINGS_MAX_HEADER_LIST_SIZE`).
- **Один h2-коннект и балансировка**: L4-балансировщик "приклеивает" весь h2-трафик к одному бэкенду (одно соединение), что ломает балансировку. Для gRPC нужен L7-балансировщик или client-side LB.
- **`GOAWAY`** при graceful shutdown: сервер шлёт GOAWAY, чтобы клиент не слал новые streams; неучтённый GOAWAY → ошибки на рестартах/деплоях.
- **Rapid Reset (CVE-2023-44487)** — DoS через быстрое открытие/RST_STREAM множества h2-потоков; Go патчился, лимиты на конкурентные streams важны.
- **HTTP/3 и UDP в инфраструктуре**: файрволлы/NAT/балансировщики могут не пропускать UDP/443 → нужен fallback на h2.

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

**В:** Почему pipelining в HTTP/1.1 не прижился?
**О:** Ответы обязаны идти в порядке запросов → head-of-line blocking, плюс множество багов в прокси/серверах. Браузеры его отключили, предпочитая несколько параллельных соединений.

**В:** HTTP/2 решает HoL blocking. Полностью?
**О:** Только на уровне приложения (мультиплексирование streams). На уровне TCP HoL остаётся: потеря одного сегмента блокирует доставку всех streams, т.к. TCP — упорядоченный байт-поток. Полностью решает HTTP/3 поверх QUIC.

**В:** Что такое HPACK и зачем он?
**О:** Сжатие HTTP-заголовков в h2: статическая таблица частых заголовков + динамическая (накапливается per-connection) + Huffman-кодирование. Экономит на повторяющихся заголовках. Спроектирован устойчивым к CRIME (в отличие от наивного gzip заголовков).

**В:** Почему один h2-коннект ломает балансировку нагрузки?
**О:** Все запросы мультиплексируются в одно TCP-соединение. L4-балансировщик видит один коннект и шлёт его на один бэкенд → нагрузка не размазывается. Решение: L7-балансировка (видит отдельные streams) или client-side балансировка (gRPC).

**В:** В каком сценарии HTTP/1.1 может быть быстрее HTTP/2?
**О:** На сильно лоссистой сети: h2 на одном TCP страдает от TCP HoL (потеря блокирует все streams), а несколько независимых h1-соединений изолируют потери. Отсюда мотивация HTTP/3.

**В:** Как в Go включается HTTP/2?
**О:** Автоматически на TLS-сервере/клиенте через ALPN (`h2`). Для cleartext (h2c) нужна явная настройка через `golang.org/x/net/http2`. gRPC всегда использует h2.

**В:** Что такое Alt-Svc и зачем он для HTTP/3?
**О:** Заголовок, которым сервер по h1/h2 анонсирует доступность h3 (`Alt-Svc: h3=":443"`). Клиент запоминает и при следующих запросах пробует QUIC, с fallback на TCP, если UDP заблокирован.

**В:** Почему server push в HTTP/2 фактически мёртв?
**О:** Плохо взаимодействовал с клиентским кэшем (push того, что уже в кэше — трата трафика), сложен в настройке, выигрыш мал. Chrome убрал поддержку. Замена — `103 Early Hints` с preload-подсказками.

## На что копают на senior+
- Различие flow control: TCP-окно vs h2 stream/connection windows vs QUIC flow control — три независимых уровня.
- Почему QPACK сложнее HPACK (отсутствие гарантированного порядка между QUIC-streams → риск HoL в самой таблице сжатия, решается dynamic table с подтверждениями).
- Rapid Reset (CVE-2023-44487): механика атаки и почему лимит `MaxConcurrentStreams` сам по себе не спасает.
- gRPC поверх h2: keepalive ping'и, `MAX_CONCURRENT_STREAMS`, почему нужен пул каналов или L7-LB.
- Деплой HTTP/3 в реальной инфраструктуре: UDP buffer sizes, GSO, fallback-логика, проблемы с middleboxes.
- `GOAWAY`-семантика и graceful drain при деплоях, как Go-сервер это обрабатывает в `Shutdown`.