Ключевые выводы

Go награждает скучную дисциплину. Senior-уровень здесь — не магия обобщений и не знание всех флагов компилятора, а предсказуемые пакеты, явные ошибки, понятные интерфейсы и сервисы, которые переживают рестарт без сюрпризов.

Уровни — про зону ответственности, а не про годы. Junior закрывает задачу в известном контуре; Middle сам доводит изменение до прода с метриками и откатом; Senior меняет контур: контракты, деградацию, онбординг и качество решений команды.

Сначала глубина стандартной библиотеки, потом фреймворки. net/http, context, database/sql, testing, sync закрывают большую часть серверной работы. Gin/Echo/Fiber полезны, но не заменяют понимание того, что происходит под ними.

Конкурентность без моделей отказа — ловушка. Горутины дешёвые; утечки, гонки и «забытый» context дорогие. Детектор гонок и профилирование — обязательные инструменты Middle, не «продвинутый факультатив».

Карта обучения должна быть привязана к продукту. Лучший учебник — ваш сервис: реальные инциденты, медленные запросы, кривые деплои. Курсы без прод-контекста дают ложное чувство Senior.

Что на самом деле означают Junior, Middle и Senior в Go

Формальные грейды в компаниях размыты, но в Go-командах есть повторяющийся паттерн ожиданий.

Junior пишет рабочие фичи под ревью: эндпоинт, миграция, простой воркер. Нужна помощь с дизайном пакетов, граничными случаями и «как это будет в проде». Ошибки ожидаемы; опасны только те, что тихо портят данные.

Middle самостоятельно ведёт вертикальный срез: API → БД → фоновая задача → метрики → деплой. Читает чужой код без паники, ловит гонки, умеет объяснить компромисс «ещё один сервис vs модуль в монолите». Знает, где искать в pprof и логах.

Senior отвечает за качество системы, а не только за задачу в трекере. Снижает стоимость изменений: чёткие границы пакетов, контракты, стратегии деградации, онбординг. Часто пишет меньше «нового кода», но больше решений, которые не придётся переписывать через полгода.

Почему Go популярен именно в серверном мире — отдельно разобрано в «Почему Go стал одним из самых популярных языков серверной разработки». Этот лонгрид — про карьерную карту поверх той экосистемы.

Карта компетенций: от синтаксиса до ответственности за систему

Удобно думать о четырёх слоях. На каждом грейде все слои есть, но меняется глубина.

Смежные темы из соседних статей блога помогают «закрыть дыры» без смены стека: как запрос идёт от браузера до БД — в «От браузера к базе данных»; очереди и воркеры на PostgreSQL + Go — в разборе очереди заданий.

Junior: фундамент без лишней теории

Цель этапа — уверенно писать и читать идиоматичный Go в небольшом сервисе, не боясь стандартной библиотеки.

Язык, модули, стиль

Изучите типы, структуры, указатели, слайсы, отображения, методы, встраивание, пакеты и go.mod. Привыкните к gofmt / goimports как к норме: в экосистеме Go стиль почти не обсуждают на ревью — обсуждают поведение.

Поймите разницу между значением и указателем на практике: копирование структур, мутации, когда указатель оправдан. Не тащите «везде указатели, как в C++» — это частый антипаттерн новичков.

Ошибки как часть контракта

В Go ошибка — значение. Junior должен уметь:

• возвращать error вместо паники в бизнес-логике;
• оборачивать с %w и проверять через errors.Is / errors.As;
• не глотать ошибки пустым _ =;
• писать сообщения, по которым потом найдут инцидент в логах.

Паника — для действительно невозможных состояний программы, не для «пользователь ввёл плохой JSON».

HTTP и простой сервис

Соберите сервис на net/http: маршруты, JSON, статус-коды, промежуточный слой для логирования и идентификатора запроса. Фреймворк можно добавить позже; сначала поймите ServeHTTP, контекст запроса и жизненный цикл ответа.

Подключите PostgreSQL или SQLite через database/sql: параметризованные запросы, сканирование строк, базоные транзакции. ORM на этом этапе часто мешает увидеть SQL.

Тесты с первого месяца

Табличные тесты (t.Run), сравнения через cmp или явные проверки, моки только там, где без них нельзя. Не гонитесь за «100 % покрытием кода» — гонитесь за тестами на границы: пустой ввод, таймаут, дубликат ключа.

Что ещё полезно Junior

• go test, go vet, базовый golangci-lint;
• отладка в Delve или IDE;
• чтение коротких стандартных пакетов (io, bufio, encoding/json) как эталона стиля;
• git-дисциплина: маленькие коммиты, понятные PR.

Middle: идиомы, конкурентность и продакшен

Переход в Middle — когда вы перестаёте «писать фичу» и начинаете держать поведение системы.

Идиоматичный дизайн

Интерфейсы объявляйте у потребителя, маленькими (io.Reader-стиль). Не рисуйте огромные IUserRepository заранее «на вырост» — это Java-привычка, которая в Go часто даёт шум без пользы.

Композиция вместо наследования: встраивание структур используйте осознанно; скрытые продвижения методов легко ломают читаемость.

Обобщения (с Go 1.18) — инструмент для контейнеров и общих алгоритмов, не для «сделать всё обобщённым». Если конкретный тип читается лучше — оставляйте конкретный.

Конкурентность как инженерная дисциплина

Горутины, каналы, select, sync.Mutex / WaitGroup / Once, пулы рабочих процессов. Главное — модели остановки: кто отменяет работу, что происходит при ошибке одного воркера, куда утекает горутина при возврате из обработчика.

context.Context должен идти через API почти везде, где есть I/O. Таймауты на исходящие вызовы — норма, не оптимизация.

Обязательно прогоняйте go test -race в CI. Гонки в Go не «теоретические» — они всплывают под нагрузкой и портят данные тихо.

Надёжность на границе систем

Повторные попытки с нарастающей задержкой и случайным разбросом, идемпотентность обработчиков, дедупликация, лимиты на размер тела запроса, валидация входных данных. Для очередей и фоновых задач полезен опыт вроде очереди заданий на PostgreSQL и Go: аренда, повторы, наблюдение за зависшими заданиями.

Наблюдаемость

Структурированные логи (JSON), корреляция по идентификатору запроса, метрики RED (частота, ошибки, длительность) для HTTP, USE для воркеров. Трейсы через OpenTelemetry — когда сервисов больше одного или латентность «гуляет».

Профилирование: net/http/pprof, go tool pprof для CPU и кучи. Middle должен хотя бы раз поймать утечку или горячую функцию профилем, а не догадкой.

Данные и миграции

Индексы под реальные запросы, EXPLAIN, пул соединений, контексты на запросы. Миграции — обратимые или с планом отката. Понимание уровней изоляции хотя бы на уровне «почему у нас фантомное чтение в отчёте».

Сборка и деплой

Статический бинарник, многостадийная сборка Docker, проверки живучести и готовности, корректное завершение (signal.Notify, Server.Shutdown). В контейнерном мире важно понимать, что запускает ваш процесс — см. также разбор изоляторов и среды выполнения.

Senior: архитектура, надёжность и влияние на команду

Senior в Go-команде узнают не по числу звёзд на GitHub, а по тому, дешевле ли системе жить после его решений.

Границы и эволюция

Пакеты отражают предметные области, а не слои «модели/контроллеры» ради привычки. Публичный API модуля стабилен; внутренности можно ломать. Версионирование модулей и обратная совместимость HTTP/gRPC — часть работы, не «потом».

Умение сказать «нет» новому микросервису: иногда модуль и чёткая граница пакета дешевле распределённой системы. Контекст — эволюция архитектуры веб-приложений.

Модели отказов

Что будет, если PostgreSQL медленный? Если зависимый сервис вернул 503? Если диск заполнен? Senior проектирует деградацию: кэш, очереди, частичный ответ, размыкатель цепи — с явными метриками и инструкцией для дежурных.

Безопасность на уровне сервиса: секреты не в репозитории, минимальные привилегии БД, защита от типичных дыр API. Подход «безопасность — часть дизайна» переносится с любых стеков; полезный чеклист мышления — даже из обзора рисков Node.js, адаптированный под Go.

Производительность как экономика

Не «оптимизировать всё», а измерять. Аллокации в горячих путях, размер JSON, лишние копии слайсов, блокировки. Иногда правильный ответ — проще код и вертикальное масштабирование на месяц, а не неделя микрооптимизаций.

Люди и процесс

Ревью, которые учат; RFC на спорные изменения; упрощение онбординга; удаление мёртвого кода. Senior снижает зависимость от отдельных людей: документация решений (ADR), карты зависимостей, понятные алерты.

В эпоху ассистентов на базе ИИ Senior ещё и задаёт рамки: что можно генерировать, что проверять обязательно, где модель врёт уверенно — см. опыт разбора унаследованных систем с ИИ.

Что учить не нужно (или гораздо позже)

Список «отложить» экономит месяцы.

Тяжёлые фреймворки как первый шаг. Пока не ясны net/http и промежуточный слой, написанный своими руками, фреймворк прячет стоимость абстракций.

Операторы Kubernetes и controller-runtime. Это отдельная специализация платформенной инженерии. Сначала — обычный сервис, который корректно живёт в Kubernetes.

Глубокая внутренняя работа Go (детали GC) до профилей. Полезно Senior'у под конкретный инцидент; вредно Junior'у как замена практике.

Все ORM и генерация кода сразу. Выберите один путь (sqlc/pgx/database/sql) и доведите до мастерства.

«Выучить Rust, чтобы стать лучше в Go». Смежные языки полезны, но не как обязательный квест грейда. Сравнение стеков имеет смысл для выбора инструмента, не для статуса.

Бесконечные курсы без прод-задачи. Один инцидент с гонкой учит сильнее, чем три сертификата.

Практический план обучения по этапам

План — ориентир на 6–18 месяцев в зависимости от нагрузки на работе. Лучше медленнее и с продуктом, чем быстрее и только на туториалах.

Этап A — первые 2–3 месяца (основа Junior)

1. Пройти интерактивный курс Go и руководство по идиоматичному Go; писать код каждый день хотя бы по часу.
2. Собрать CLI + маленький HTTP API с JSON и тестами.
3. Подключить БД, сделать CRUD и одну транзакцию «деньги/остатки» (учебный домен).
4. Настроить линтер и CI на go test ./....
5. Прочитать исходники 2–3 пакетов стандартной библиотеки по интересу (например net/http кусками).

Этап B — следующие 3–6 месяцев (к Middle)

1. Добавить фонового воркера, ретраи, идемпотентность.
2. Внедрить структурированное журналирование и базовые метрики.
3. Намеренно устроить гонку и поймать её -race.
4. Профилировать CPU на синтетической нагрузке (hey/vegeta).
5. Сделать корректное завершение и правильные проверки в Docker Compose.
6. Написать разбор причин учебной или реальной ошибки.

Этап C — путь к Senior (параллельно с работой)

1. Возглавить дизайн нетривиального изменения (контракт API, миграция данных).
2. Упростить пакетную структуру легаси-сервиса без «большого взрыва».
3. Настроить SLO/алерты и доказать полезность метрикой (меньше ложных страниц).
4. Провести 3–5 менторских сессий с Junior: разбор PR, карта обучения.
5. Написать ADR по спорному решению и вернуться к нему через квартал — сработало ли.

Измеряйте прогресс артефактами: сервисы в проде, постмортемы, упрощения, менторство — не количеством просмотренных часов видео.

Типичные ошибки на пути

Гнаться за «Senior» через микросервисы. Два плохо связанных сервиса хуже одного ясного модуля.

Игнорировать ошибки и контекст. go func() { ... }() без контроля жизненного цикла — классика инцидентов.

Тесты только для успешного сценария. Прод ломается на пустых слайсах, частичных сбоях сети и двойных отправках.

Копировать Java/TypeScript стиль в Go. Толстые иерархии, огромные интерфейсы, DI-контейнеры «потому что так принято» усложняют чтение.

Оптимизировать без измерений. sync.Pool и ручное повторное использование объектов до профиля — часто шум.

Учить только синтаксис конкурентности. Без обратного давления и таймаутов получите систему, которая «держит миллион горутин» и умирает на первом всплеске.

Считать, что фреймворк = архитектура. Архитектура — границы и потоки данных; фреймворк — удобство транспорта.

Сравнение ожиданий: Go и другие серверные стеки

Команды часто сравнивают Go с Node/TypeScript, Java и Rust. Смысл сравнения — понять, какие навыки переносятся.

Переходя в Go из другого стека, не выбрасывайте системное мышление (транзакции, идемпотентность, безопасность). Выбрасывайте привычку тащить тяжёлые абстракции «на всякий случай».

Частые вопросы

Дальнейшее чтение

Внутри блога логично продолжить такими материалами:

• Почему Go популярен в серверной разработке — контекст экосистемы и сильных сторон языка
• Очередь заданий на PostgreSQL и Go — воркеры, аренда, повторные попытки
• От браузера к базе данных — сквозной путь запроса
• Эволюция архитектуры веб-приложений — когда дробить систему
• Скрытые риски безопасности в Node.js — чеклист мышления о безопасности API (переносимо)
• Изоляторы контейнеров и среда выполнения — что реально запускает ваш бинарник
• ИИ и унаследованные проекты — как ускорять разбор сложных систем без слепого доверия

Внешние официальные материалы: руководство по идиоматичному Go, рекомендации по ревью кода Go, блог Go.

Заключение

Путь от Junior до Senior в Go — это путь от «код компилируется» к «система предсказуемо ведёт себя, когда всё ломается». Учите стандартную библиотеку и идиомы раньше фреймворков; конкурентность — вместе с моделями отказа; карьеру измеряйте артефактами в проде и влиянием на команду.

Практический шаг на этой неделе: возьмите один свой сервис и закройте один пробел Middle-уровня — -race в CI, корректное завершение, одну RED-метрику или тест на граничный случай. Грейд сдвигается такими шагами, а не новым сертификатом.