Skip to content
The Chat Archive
gpt-4.1-mini-2025-04-14· OpenAI WildChat-4.8M (AI2)

Я начинающий backend-developer в основном на языке golang. Я уже успел разобрать tour of…

  1. User

    Я начинающий backend-developer в основном на языке golang. Я уже успел разобрать tour of go, познакомится с базовыми концепциями языка(срезы, гоурутины и т.д), понемногу осваиваю стандартную библиотеку. Так же я успел написать 2 телеграмм-бота и 1 текстовую игру, начал писать веб-сервис, однако показалось сложновато, думаю слегка замедлить темп и повторить основы. Я умею на базовом уровне работать с github, знаю самые нужные и популярные команды, все свои проекты я успешно сохранил на github. Так вот, моя проблема в том, что я хочу перейти к изучению новых технологий, но не понимаю в какой последовательности к ним подходить(если что, я могу изучать технологии параллельно, т.е к примеру 80% усилий направить на изучение докера, а 20% на СУБД(Это лишь пример!!!)), глаза разбегаются и не могу выбрать куда бы углубиться. Хотелось бы, чтобы ты дал мне четкий график с теми технологиями, которые мне надо будет изучать и в какой последовательности.

    Параллельно с получением каких-то теоретических знаний я бы хотел немедля их закрепить на практике путем написания пет-проектов, или выполнения блока каких-либо маленьких задач(к примеру, если технология не слишком глобальная то написание пет-проекта может привести к большой потере времени).

    Так же напомню, что помимо изучения новых технологий, хотел бы укрепить базу(ключевые слова в golang и стандартная библиотека со всеми особенностями ее применения). Для этого выдели так же список задач для строго последовательного выполнения, одна за другой.

  2. Assistant

    Отлично, что у тебя уже есть базовые знания Go и небольшой опыт в разработке — это хорошая отправная точка! Я составлю для тебя подробный поэтапный план обучения, разделённый на блоки:

    1. Углубление Go как языка и стандартной библиотеки
    2. Основы backend-разработки на Go
    3. Важные сопутствующие технологии и концепции (базы данных, контейнеры, HTTP и пр.)
    4. Продвинутые темы и DevOps-инструменты для backend-разработчика

    Каждый этап будет дополнен техническими задачами или pet-проектами для закрепления. Можешь выделять пропорции времени примерно как ты предложил, но цикл «теория → практика» должен поддерживаться всегда.


    1. Углубление Go, изучение стандартной библиотеки и базовых концепций

    Цель: на уровне реального продакшен-кода свободно использовать синтаксис, библиотеки, эффективно работать с ошибками, знать стандартные паттерны.

    Что изучать

    • Подробности о функциях, методах, интерфейсах, вложенных структурах
    • Работа с ошибками (error wrapping, custom errors, errors.Is, errors.As)
    • Стандартная библиотека:
      • context — управление жизненным циклом (горутин, запросов)
      • Работа с io (Reader, Writer, ReadCloser и пр.)
      • Работа с файлами/потоками (os, bufio, io/ioutil)
      • Форматирование (fmt), конвертация (strconv)
      • Строки и регулярные выражения (strings, regexp)
      • Работа с json / xml (encoding/json, encoding/xml)
      • Синхронизация и concurrency primitives (sync, sync/atomic)
      • time и таймеры, тики (time)
    • Понимание горутин, каналов, их взаимодействия
    • Использование пакетных модулей (модули go, зависимости)

    Задачи для закрепления

    1. Написать небольшой пакет с кастомными ошибками и конвертацией между ними (пример: валидатор вводимых данных)
    2. Реализовать функцию сериализации/десериализации структуры в json и обратно, с расширенной обработкой ошибок
    3. Написать утилиту, читающую из файла логи, фильтрующую по паттернам (regexp), выводящую статистику
    4. Написать собственный пакет для работы с контекстом, где придётся запускать горутины с отменой по таймауту
    5. Реализовать примитивный пул горутин с управлением максимальным числом одновременных задач

    2. Основы backend-разработки на Go

    Цель: понять, как делать реальные серверные приложения — принимать HTTP-запросы, обрабатывать, возвращать ответы, уметь отлаживать, логировать.

    Что изучать

    • HTTP в Go: пакет net/http и создание простых веб-серверов
    • Работа с хендлерами (http.Handler, ServeMux)
    • Маршрутизация (поищи сторонние роутеры, например, gorilla/mux или chi)
    • Форматы обмена данными (JSON, form-data)
    • Работа с middleware (логирование, авторизация, CORS, recovery)
    • Логирование (например, zap, logrus, но и стандартный log)
    • Конфигурация приложений (переменные окружения, конфиг-файлы, flag)
    • Знакомство с REST API: принципы, коды состояния HTTP, idempotency
    • Работа с HTTP-клиентом (например, для интеграции с внешними сервисами)

    Задачи для закрепления

    1. Написать REST API сервер с одним ресурсом (например, todo или users) с CRUD операциями
    2. Добавить middleware логирования входящих запросов и вывод их в консоль
    3. Добавить обработку ошибок и возврат корректных HTTP-статусов с понятным JSON-ответом
    4. Написать клиент для собственного API и проверить работу эндпоинтов
    5. Расширить API поддержкой пагинации и фильтров

    3. Технологии сопутствующего стека

    Цель: освоить наиболее востребованные компоненты, которые дополняют backend — базы данных, cache, контейнеризация.

    Что изучать (рекомендуемый порядок)

    3.1 Работа с СУБД

    • Реляционные: PostgreSQL (лучше, чем MySQL, для backend-разработчика в целом)
    • Знакомство с библиотеками: database/sql + драйвер pgx (или lib/pq)
    • SQL-запросы, миграции (например, через golang-migrate)
    • Основы нормализации, индексов, транзакций
    • ORM или query builders (например, sqlx, gorm — выбрать один)

    Параллельно

    • NoSQL базы (кратко) — Redis (кэш, очередь сообщений)
    • Знакомство с сессиями, хранением данных в Redis, TTL

    3.2 Docker и контейнеризация

    • Что такое контейнер, образы, Dockerfile
    • Написание простого Dockerfile для Go-приложения
    • Запуск контейнера, монтирование томов, сетевые настройки
    • Docker Compose для сборки связки из нескольких сервисов (API + БД)

    Задачи для практики

    1. Написать CRUD API для PostgreSQL — загрузка, изменение, удаление данных через БД
    2. Добавить к API поддержку paginации запросов через БД
    3. Реализовать кэширование часто запрашиваемых ресурсов в Redis
    4. Подготовить Dockerfile для своего API сервера
    5. Настроить Docker Compose для запуска API + PostgreSQL + Redis локально
    6. Написать простой скрипт миграции схемы БД (создания таблиц) и применить

    4. Продвинутые темы и DevOps основы

    Цель: познакомиться с тем, что поможет писать и запускать масштабируемые, безопасные и надежные backend-сервисы.

    Что изучать

    • API-аутентификация и авторизация (JWT, OAuth2 базово)
    • Тестирование: юнит-тесты, интеграционные тесты, мокирование (testing, testify, gomock)
    • Профилирование и оптимизация (pprof, race detector)
    • CI/CD основы (GitHub Actions, GitLab CI)
    • Метрики и мониторинг (Prometheus + Grafana) — хотя бы базовые понятия и экспорт метрик из Go
    • Ознакомление с gRPC (можно начать позже)

    Задачи

    1. Добавить аутентификацию в API с JWT, защищая часть эндпоинтов
    2. Написать тесты (unit + integration) для CRUD API
    3. Создать конфигурацию GitHub Actions для тестирования и сборки Docker-образа
    4. Подключить в сервис сбор и экспорт метрик Prometheus
    5. Произвести профилирование сервиса под нагрузкой, найти и устранить бутылочные места
    6. Опционально — изучить gRPC и написать небольшой сервис с этим протоколом

    ИТОГОВЫЙ ПЛАН

    МесяцФокусТема / Задачи
    1-2Углубленный GoСтандартная библиотека, ошибки, concurrency
    3-4Основы backend, HTTP серверыREST API, middleware, логирование
    5-6Базы данных (Postgres), СУБДCRUD, миграции, query builders
    7Cache (Redis), DockerКэширование, Dockerfile, Docker Compose
    8-9Тестирование, auth, CI/CDJWT, тесты, GitHub Actions, Prometheus
    10Мониторинг, профилированиеМетрики, pprof, race detector

    Советы для усвоения

    • Всегда писать код после теории (минимум мини-проект или тестовая задача)
    • Разделяй большие задачи на маленькие — чтобы видеть прогресс и не стопориться
    • Читай официальную документацию, чтобы не привязываться только к туториалам
    • Изучай чужие проекты на GitHub (например, популярные open source backend-сервисы на Go)
    • Регулярно практикуйся, поддерживай чистоту кода и тестирование

    Если хочешь, могу помочь составить еженедельное расписание занятий или помочь под подборкой задач для текущего этапа. Удачи в изучении — Go отличный выбор для backend и очень перспективен!

  3. User

    Подробнее опиши задачу и дай более конкретное условие, я не совсем понял: Написать небольшой пакет с кастомными ошибками и конвертацией между ними (пример: валидатор вводимых данных)

  4. Assistant

    Конечно! Вот подробное и конкретное условие задачи по написанию пакета с кастомными ошибками и преобразованием между ними на примере валидатора вводимых данных.


    Задача: Пакет валидации с кастомными ошибками

    Цель

    Создать Go-пакет, который предоставляет набор функций для валидации структуры данных (например, формы регистрации пользователя или данных профиля), и возвращает информативные кастомные ошибки.

    Ошибки должны быть разных типов (например, ошибка пустого поля, ошибка некорректного формата, ошибка слишком короткого значения), поддерживать обёртку ошибок (wrapping) и удобный для клиента API для проверки типа ошибки с помощью errors.Is и errors.As.


    Условие задачи

    1. Создать пакет с именем validator (например, в директории /validator).

    2. В пакете реализовать:

      • Несколько функций валидации для примитивных типов, например:

        • ValidateNotEmpty(fieldName string, value string) error — проверяет, что строка не пустая
        • ValidateMinLength(fieldName string, value string, min int) error — проверяет минимальную длину строки
        • ValidateEmailFormat(fieldName string, value string) error — проверяет корректность email (для простоты можно использовать регулярное выражение)
      • Типы ошибок, описывающие конкретные нарушения, например:

        • ErrEmptyField
        • ErrTooShort
        • ErrInvalidFormat

      Каждая ошибка должна включать информацию о том, какое поле вызвало ошибку и почему.

    3. Тип ошибки должен реализовывать интерфейс error.

    4. Для объединения ошибок в одном поле (например, несколько ошибок из разных проверок) реализовать возможность группировки ошибок (custom error type, который содержит слайс ошибок).

    5. Дополнительно: реализовать возможность "конвертации" (приведения) ошибки к конкретному типу с помощью errors.As, а также проверки с помощью errors.Is.


    Пример использования пакета (как клиент твоего пакета будет вызывать)

    package main
    
    import (
        "fmt"
        "validator"
    )
    
    type User struct {
        Email    string
        Password string
    }
    
    func ValidateUser(user User) error {
        var verrs validator.ValidationErrors
    
        if err := validator.ValidateNotEmpty("Email", user.Email); err != nil {
            verrs.Add(err)
        }
        if err := validator.ValidateEmailFormat("Email", user.Email); err != nil {
            verrs.Add(err)
        }
        if err := validator.ValidateMinLength("Password", user.Password, 8); err != nil {
            verrs.Add(err)
        }
    
        if verrs.HasErrors() {
            return verrs
        }
        return nil
    }
    
    func main() {
        user := User{Email: "", Password: "123"}
        err := ValidateUser(user)
        if err != nil {
            fmt.Println("Ошибка валидации:")
            fmt.Println(err)
    
            // пример проверки конкретного типа ошибки
            var e *validator.ErrEmptyField
            if errors.As(err, &e) {
                fmt.Println("Найдено пустое поле:", e.FieldName)
            }
        }
    }
    

    Конкретные шаги для выполнения

    1. Определить интерфейс или базовую структуру для кастомных ошибок валидации, которая содержит:

      • Имя поля (FieldName, string)
      • Сообщение об ошибке (Message, string)
      • Тип ошибки (можно через конкретный тип или поле)
    2. Реализовать три типа ошибок, вложенных в пакет, например, как структуры, реализующие error:

    type ErrEmptyField struct {
        FieldName string
    }
    
    func (e *ErrEmptyField) Error() string {
        return fmt.Sprintf("Поле %s не должно быть пустым", e.FieldName)
    }
    
    1. Аналогично реализовать ErrTooShort и ErrInvalidFormat.

    2. Создать тип ValidationErrors, который содержит []error, реализует интерфейс error (например, метод Error() возвращает объединённую строку с сообщениями об ошибках).

    3. Добавить к ValidationErrors методы:

      • Add(err error) — добавить ошибку в список
      • HasErrors() bool — возвращает true, если есть ошибки
    4. Для функций валидации возвращать конкретные ошибки из соответствующих типов, создавать новые ошибки с заполненным полем FieldName.

    5. Поддержать использование errors.As для распознавания типов ошибок (по умолчанию это будет работать с указателем на структуры ошибок).


    Какие навыки в процессе прокачаешь?

    • Создание кастомных типов ошибок и управление ими
    • Механизм обёртки и распознавания ошибок в Go (errors.Is, errors.As)
    • Работа с интерфейсом error и пользовательскими типами
    • Сбор нескольких ошибок в одно объединённое представление
    • Хорошие практики проектирования API для возврата ошибок
    • Понимание реальных требований к валидации данных в backend

    Если хочешь, могу помочь набросать стартовый код для этого пакета! Это хороший и достаточный для уровня середнячка проект — не слишком сложный, но очень полезный.