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
- UDP — простой датаграммный транспорт: нет соединения, нет гарантий доставки/порядка, нет flow/congestion control. Только порты + контрольная сумма.
- Плюсы: минимальная латентность и накладные расходы, отсутствие head-of-line blocking, broadcast/multicast, контроль над семантикой надёжности на стороне приложения.
- Применять: DNS, DHCP, NTP, VoIP/видео (RTP), realtime-игры, метрики (statsd), service discovery, QUIC.
- "Надёжность поверх UDP" = QUIC (HTTP/3), а также кастомные протоколы (ACK, ретрансмиты, FEC, sequence numbers) — вы переносите логику TCP в userspace.
- В Go: `net.UDPConn`, `ReadFromUDP/WriteToUDP`, `net.ListenPacket`. Один сокет обслуживает множество "пиров".

## Теория

### UDP в двух словах
Заголовок UDP — всего 8 байт: source port, dest port, length, checksum. Никакого состояния. Каждый `WriteToUDP` = одна датаграмма = (обычно) один IP-пакет.

### UDP vs TCP
| Свойство | TCP | UDP |
|---|---|---|
| Соединение | да (handshake) | нет |
| Надёжность | гарантирована | нет |
| Порядок | гарантирован | нет |
| Дедупликация | да | нет |
| Flow control | да (rwnd) | нет |
| Congestion control | да (cwnd) | нет (приложение само) |
| Граница сообщений | байт-поток | сохраняется (датаграмма) |
| Overhead заголовка | 20+ байт | 8 байт |
| Multicast/broadcast | нет | да |
| Head-of-line blocking | да | нет |

### Когда выбирать UDP
- **Латентность важнее надёжности**: голос/видео — потерянный пакет лучше дропнуть, чем ждать ретрансмит.
- **Запрос-ответ малого размера**: DNS — одна датаграмма туда, одна обратно, без накладных на handshake/teardown.
- **Multicast/broadcast**: service discovery (mDNS), потоковое вещание.
- **Свой протокол надёжности**: когда нужна частичная надёжность, приоритеты, FEC, мультиплексирование без HoL — например QUIC.

### Границы датаграмм и размер
- UDP сохраняет границы: одно `Read` = одна датаграмма. Если буфер меньше датаграммы — остаток **теряется** (в отличие от TCP).
- Практический безопасный payload без фрагментации: ~**508 байт** (576 MTU IPv4 − заголовки) или ~1200 байт под типичный Ethernet MTU 1500 (так делает QUIC). Большие датаграммы фрагментируются на IP-уровне → потеря одного фрагмента губит всю датаграмму.

### Надёжность поверх UDP
Чтобы получить "TCP-подобные" гарантии, приложение реализует:
- **Sequence numbers** — порядок и детект потерь.
- **ACK / NACK** — подтверждения.
- **Ретрансмиссии** по таймауту (RTO) или по NACK.
- **Congestion/flow control** — иначе забьёте сеть.
- **FEC (forward error correction)** — избыточность вместо ретрансмита (хорошо для realtime).

### QUIC — канонический пример
QUIC (RFC 9000) — транспорт от Google, основа HTTP/3:
- Работает поверх UDP, но даёт надёжность, упорядоченность, congestion control.
- **Мультиплексирование без HoL**: независимые streams; потеря в одном не блокирует другие (в отличие от TCP под HTTP/2).
- **0-RTT / 1-RTT handshake** с встроенным TLS 1.3 — handshake транспорта и крипто слиты.
- **Connection ID**: соединение переживает смену IP (миграция сети — Wi-Fi → LTE) без реконнекта.
- Живёт в userspace → можно деплоить новые версии без обновления ядра.

### UDP в Go
```go
// Сервер
addr, _ := net.ResolveUDPAddr("udp", ":9000")
conn, _ := net.ListenUDP("udp", addr)
defer conn.Close()

buf := make([]byte, 1500) // под MTU
for {
    n, remote, err := conn.ReadFromUDP(buf)
    if err != nil { continue }
    // обработать buf[:n], remote — кто прислал
    conn.WriteToUDP([]byte("pong"), remote)
}
```
```go
// Клиент: можно Dial для "connected UDP" — фиксирует peer,
// позволяет получать ICMP-ошибки (port unreachable) на Read/Write.
conn, _ := net.Dial("udp", "1.2.3.4:9000")
conn.Write([]byte("ping"))
```
- `net.ListenPacket("udp", ...)` — generic интерфейс `PacketConn`.
- Для QUIC в Go: библиотека `quic-go` (она же даёт HTTP/3 через `http3.Transport`/`http3.Server`).

## Подводные камни / gotchas
- **Маленький буфер на Read обрезает датаграмму** молча — выделяйте буфер под максимальный ожидаемый размер (или MTU).
- **Нет congestion control "из коробки"** — наивный UDP-флуд убивает сеть и сам себя (потери растут). Всегда думайте о rate limiting / backpressure.
- **Фрагментация IP** — датаграммы >MTU фрагментируются; потеря одного фрагмента = потеря всей датаграммы. Держите payload ≤ ~1200 байт.
- **"Connected UDP" vs unconnected**: `Dial` фиксирует peer и доставляет ICMP-ошибки; `ListenUDP`+`ReadFromUDP` обслуживает много пиров, но ICMP вы не увидите.
- **NAT timeout**: UDP-маппинги в NAT короткоживущие (десятки секунд). Нужны keep-alive пакеты, иначе "дыра" закроется.
- **Спуфинг source IP** тривиален (нет handshake) → UDP-протоколы (DNS, NTP, memcached) часто используются для amplification DDoS. На сервере проверяйте ratio запрос/ответ.
- **Один сокет — много горутин на Read**: `ReadFromUDP` потокобезопасен, но для масштабирования используют `SO_REUSEPORT` (несколько сокетов, балансировка ядром).

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

**В:** Почему DNS использует UDP, а не TCP?
**О:** Малый запрос/ответ, латентность критична, нет смысла в handshake ради одного пакета. При ответе >512 байт (или с EDNS — >объявленного размера) или при zone transfer DNS переключается на TCP (флаг TC — truncated).

**В:** Какие гарантии НЕ даёт UDP и что придётся делать самому?
**О:** Нет доставки, порядка, дедупликации, flow/congestion control. Чтобы получить надёжность — sequence numbers, ACK/NACK, ретрансмиты по RTO, congestion control, опционально FEC. Это, по сути, реимплементация TCP в userspace (что и делает QUIC).

**В:** Что произойдёт, если датаграмма больше размера буфера в Read?
**О:** В UDP границы сохраняются: лишнее обрезается и теряется (не дочитывается следующим Read, как в TCP). Поэтому буфер выделяют под максимальный размер.

**В:** Зачем QUIC, если есть TCP+TLS?
**О:** QUIC убирает HoL blocking на уровне транспорта (независимые streams), сливает TLS 1.3 в handshake (0/1-RTT), переживает смену IP через Connection ID, живёт в userspace (быстрая эволюция). TCP+TLS страдает от HoL на L4 и более дорогого handshake.

**В:** Что такое "connected UDP" и зачем он?
**О:** `Dial("udp", ...)` ассоциирует сокет с конкретным peer. Тогда ядро доставляет ICMP-ошибки (например port unreachable) как ошибку на Read/Write, и можно использовать `Write`/`Read` без указания адреса. Для unconnected сокета ICMP вы не получите.

**В:** Как UDP-сервис может стать вектором amplification DDoS?
**О:** Source IP не верифицируется (нет handshake). Атакующий шлёт мелкий запрос со spoofed IP жертвы, сервис отвечает крупным ответом жертве. Защита: ограничивать коэффициент усиления, rate limiting, response rate limiting, требовать токены/cookie.

**В:** Почему наивный UDP-протокол может работать хуже TCP под потерями?
**О:** Без congestion control он не сбавляет темп при потерях, увеличивая заторы и собственные потери; без ретрансмитов теряет данные. TCP адаптивно реагирует на потери. Поэтому "просто UDP для скорости" без контроля перегрузки — антипаттерн.

**В:** Как масштабировать приём UDP на многих ядрах?
**О:** `SO_REUSEPORT` — несколько сокетов на одном порту, ядро балансирует датаграммы между ними по 4-tuple, каждый сокет читает своей горутиной/тредом, избегая контеншена на одном сокете.

## На что копают на senior+
- Детали QUIC: streams vs connection, 0-RTT и его replay-риски, connection migration, как congestion control (BBR/CUBIC) реализован в userspace.
- Почему QUIC выбрал UDP, а не новый L4-протокол (middlebox ossification — файрволлы/NAT режут всё кроме TCP/UDP).
- FEC vs ретрансмиты: trade-off для realtime (доп. трафик vs доп. латентность).
- GSO/GRO и offloading для высокопроизводительного UDP (важно для QUIC-серверов, исторически медленных).
- Точный расчёт безопасного payload под Path MTU, поведение DF-бита и PMTUD для UDP.
- mDNS/SSDP/multicast-группы и проблемы их работы в облаке (часто multicast недоступен).