🤔 Зачем нужна Grafana?

Grafana — это инструмент для визуализации и мониторинга данных. Он позволяет строить дашборды (панели) с графиками, метриками и алертами, получая данные из различных источников (Prometheus, InfluxDB, Loki, MySQL и других).

🚩Основные возможности Grafana

🟠Визуализация данных
создание графиков, таблиц, гистограмм и других визуальных представлений.
🟠Мониторинг в реальном времени
отслеживание метрик серверов, баз данных, контейнеров и микросервисов.
🟠Гибкость источников данных
поддерживает Prometheus, Elasticsearch, MySQL, PostgreSQL и десятки других.
🟠Настраиваемые алерты
оповещения (email, Slack, Telegram) при достижении критических значений.
🟠Дашборды для DevOps
удобный интерфейс для анализа производительности систем.

🚩Зачем нужна Grafana?

🟠Для мониторинга серверов и приложений
Можно отслеживать загрузку CPU, RAM, количество запросов в базе, ошибки и задержки API.

🟠Для DevOps и SRE
Позволяет наблюдать за работой Kubernetes, Docker, CI/CD-пайплайнов и микросервисов.

🟠Для бизнес-аналитики
Может использоваться для отображения KPI, продаж, конверсий и других данных.

🟠Для алертов и оповещений
Если сервер падает или нагрузка превышает порог – Grafana уведомит команду.

🚩Пример использования Grafana с Prometheus

Устанавливаем Prometheus и Grafana
Добавляем Prometheus как источник данных в Grafana
Создаём дашборд с метриками, например
Количество HTTP-запросов
Время ответа сервера
Количество активных соединений

http_requests_total{job="web_service"}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что известно о sync.Map?

Это потокобезопасная структура данных для одновременного доступа из нескольких горутин:
1. Не требует мьютексов для чтения/записи.
2. Оптимизирован для сценариев с частым чтением и редкой записью.
3. Поддерживает методы Load, Store, Delete, Range.
Подходит для кэшей и других сценариев, где производительность важнее.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое репликация?

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

🚩Цели

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

🟠Распределение нагрузки
Может помочь распределить запросы чтения между несколькими узлами, тем самым уменьшая нагрузку на один сервер и улучшая время отклика в приложениях.

🟠Геораспределение
Реплик в разных географических локациях может улучшить время доступа к данным для пользователей, которые находятся ближе к одной из реплик.

🟠Обеспечение безопасности данных
Данных на разные физические места уменьшает риски, связанные с потерей данных в случае катастроф.

🚩Типы

🟠Синхронная репликация
Данные одновременно записываются в основную и реплицированную базы данных. Транзакция считается завершенной только после успешной записи на всех репликах. Это обеспечивает высокую степень согласованности данных, но может снижать производительность из-за задержек, связанных с ожиданием подтверждения от всех реплик.

🟠Асинхронная репликация
Изменения данных первоначально записываются на основной сервер, и только после этого асинхронно передаются на репликационные серверы. Это метод быстрее, поскольку основная система не ждёт подтверждения от реплик перед завершением транзакции. Однако это также увеличивает риск несогласованности данных между репликами.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как объединить по смыслу Map и Мьютексы?

Для безопасного использования карты (Map) в многопоточном окружении:
1. Создайте карту и мьютекс как пару.
2. Заблокируйте мьютекс перед доступом к карте, разблокируйте после.
3. Используйте sync.Map, если не хотите вручную управлять блокировками.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие есть особенности синтаксиса получения и записи значений в map?

Карты (maps) представляют собой ассоциативные массивы, которые связывают ключи с соответствующими значениями. Работа с картами включает получение и запись значений, и Go предоставляет удобный синтаксис для этих операций. Рассмотрим особенности синтаксиса получения и записи значений в карты.

🚩Получение значений

🟠Простое получение значения по ключу
Для этого используется синтаксис индексирования

value := myMap[key]

Пример

package main

import "fmt"

func main() {
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }

    value := myMap["Alice"]
    fmt.Println("Alice:", value) // Alice: 25
}

🟠Проверка существования ключа
Для этого используется синтаксис двойного присваивания

value, exists := myMap[key]

Пример

package main

import "fmt"

func main() {
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }

    value, exists := myMap["Charlie"]
    if exists {
        fmt.Println("Charlie:", value)
    } else {
        fmt.Println("Charlie not found")
    }
}

🚩Запись значений

🟠Добавление или обновление значения
Для этого используется синтаксис индексирования:

myMap[key] = value

Пример

package main

import "fmt"

func main() {
    myMap := map[string]int{}

    // Добавление значений
    myMap["Alice"] = 25
    myMap["Bob"] = 30

    fmt.Println("Map:", myMap) // Map: map[Alice:25 Bob:30]

    // Обновление значения
    myMap["Alice"] = 26
    fmt.Println("Updated Map:", myMap) // Updated Map: map[Alice:26 Bob:30]
}

🟠Удаление значений из карты
Для этого используется встроенная функция delete:

delete(myMap, key)

Пример

package main

import "fmt"

func main() {
    myMap := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }

    // Удаление значения по ключу
    delete(myMap, "Alice")
    fmt.Println("Map after deletion:", myMap) // Map after deletion: map[Bob:30]
}

🟠Подводные камни и особенности

🟠Отсутствие ключа
Если ключ отсутствует в карте, при попытке получения значения будет возвращено нулевое значение типа значения карты. Например, для карты map[string]int это будет 0.

        package main

    import "fmt"

    func main() {
        myMap := map[string]int{
            "Alice": 25,
        }

        value := myMap["Bob"] // Ключ "Bob" отсутствует
        fmt.Println("Value:", value) // Value: 0
    }
    

🟠Запись в неинициализированную карту
Нельзя записывать значения в nil карту. Это приведет к панике времени выполнения.

        package main

    func main() {
        var myMap map[string]int // nil карта
        myMap["Alice"] = 25      // Вызовет панику: runtime error: assignment to entry in nil map
    }
    

🟠Итерация по карте
Порядок итерации по карте не определен и может различаться между разными запусками программы.

        package main

    import "fmt"

    func main() {
        myMap := map[string]int{
            "Alice": 25,
            "Bob":   30,
            "Carol": 35,
        }

        for key, value := range myMap {
            fmt.Printf("%s: %d\n", key, value)
        }
    }
    

Ставь 👍 и забирай 📚 Базу знаний

🤔 Чем отличается RW мьютекс от обычного?

1. RWMutex (Read-Write Mutex):
- Позволяет нескольким горутинам одновременно читать данные (RLock/RUnlock).
- Запись (Lock/Unlock) блокирует всех, включая читателей.
2. Обычный Mutex:
- Полностью блокирует доступ, независимо от операции (чтение или запись).
RWMutex эффективнее для операций с преобладанием чтения.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое iota?

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

🚩Основные характеристики

🟠Инициализация с нуля
Начинает счет с 0 в каждой новой группе констант.
🟠Автоматическое увеличение
Каждое последующее использование iota в одной группе констант увеличивает его значение на 1.
🟠Повторное использование
При каждом новом объявлении константного блока iota сбрасывается до 0.

package main

import "fmt"

const (
    A = iota // 0
    B        // 1
    C        // 2
)

func main() {
    fmt.Println(A) // Вывод: 0
    fmt.Println(B) // Вывод: 1
    fmt.Println(C) // Вывод: 2
}

Использование его для создания битовых флагов

package main

import "fmt"

const (
    Flag1 = 1 << iota // 1 << 0 = 1
    Flag2             // 1 << 1 = 2
    Flag3             // 1 << 2 = 4
    Flag4             // 1 << 3 = 8
)

func main() {
    fmt.Println(Flag1) // Вывод: 1
    fmt.Println(Flag2) // Вывод: 2
    fmt.Println(Flag3) // Вывод: 4
    fmt.Println(Flag4) // Вывод: 8
}

Сброс его в новом блоке

package main

import "fmt"

const (
    X = iota // 0
    Y        // 1
)

const (
    Z = iota // 0 (новый блок констант, iota сбрасывается)
    W        // 1
)

func main() {
    fmt.Println(X) // Вывод: 0
    fmt.Println(Y) // Вывод: 1
    fmt.Println(Z) // Вывод: 0
    fmt.Println(W) // Вывод: 1
}

🚩Комплексное использование

Можно использовать в выражениях и совместно с другими константами для создания более сложных последовательностей.

package main

import "fmt"

const (
    _ = iota             // пропускаем 0
    KB = 1 << (10 * iota) // 1 << 10 = 1024
    MB                   // 1 << 20 = 1048576
    GB                   // 1 << 30 = 1073741824
)

func main() {
    fmt.Println("KB:", KB) // Вывод: KB: 1024
    fmt.Println("MB:", MB) // Вывод: MB: 1048576
    fmt.Println("GB:", GB) // Вывод: GB: 1073741824
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое starvation/голодание?

Голодание (starvation) — ситуация, когда горутина или процесс не получают доступа к ресурсу из-за приоритета других задач. Причины:
1. Неправильное управление приоритетами.
2. Частое использование долгих блокировок (например, приоритетная блокировка RWMutex для записи).
Результат: одни задачи постоянно выполняются, другие блокируются бесконечно.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 В чем отличия http 1.1 и http 2?

Это версии протокола HTTP, каждая из которых имеет свои особенности и улучшения по сравнению с предыдущими версиями. Важные различия между этими версиями включают следующие аспекты:

🚩Мультиплексирование

🟠HTTP/1.1
Поддерживает одновременное открытие нескольких TCP соединений (обычно 6-8), что позволяет загружать несколько ресурсов параллельно. Однако каждое соединение может обрабатывать только один запрос за раз, что приводит к задержкам из-за блокировки очереди (head-of-line blocking).

🟠HTTP/2
Вводит мультиплексирование, позволяющее отправлять множество запросов и ответов асинхронно через одно единственное TCP соединение. Это значительно уменьшает задержки и улучшает производительность при загрузке страниц с большим количеством ресурсов.

🚩Бинарный протокол

🟠HTTP/1.1
Является текстовым протоколом, что означает, что запросы и ответы форматируются в виде читаемого текста.

🟠HTTP/2
Бинарный протокол, который делает передачу данных более эффективной и менее подверженной ошибкам в синтаксическом анализе. Бинарный формат упрощает реализацию парсеров и уменьшает размер передаваемых данных.

🚩Сжатие заголовков

🟠HTTP/1.1
Заголовки передаются без сжатия, что может привести к значительному объему передаваемых данных, особенно если одни и те же заголовки отправляются повторно с каждым запросом.

🟠HTTP/2
Использует механизм сжатия заголовков HPACK, который уменьшает избыточность заголовков, сжимая их перед отправкой. Это особенно эффективно для повторяющихся запросов к одним и тем же серверам.

🚩Приоритизация запросов

🟠HTTP/1.1
Не поддерживает приоритизацию запросов, из-за чего браузеры должны использовать эвристики для управления приоритетами ресурсов.

🟠HTTP/2
Поддерживает явную приоритизацию запросов, позволяя клиенту указывать приоритет обработки ресурсов, что делает загрузку страниц более эффективной.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Можно ли использовать один и тот же буфер []byte в нескольких горутинах?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

Ищу работу пол года

Практически под каждым постом в этом канале я вижу комментарии от людей, которые ищут работу по полгода. Это перерастает в обсуждение того, как нужно (или не нужно) искать работу, почему процесс найма сломан и как они откликались на фейковые вакансии.

Честно говоря, искать работу полгода — это нонсенс. Очевидно, что человек делает что-то не так. Главная ошибка, которую совершают многие, — это создание иллюзии поиска работы.

То есть человек вроде бы ищет работу, но делает это неэффективно, тратя время на нецелевые действия. Например:

➖ Просматривает вакансии перед откликом.
➖ Пытается понять, подходит ли он под вакансию. Если считает, что не подходит — не откликается.
➖ Пишет сопроводительные письма (иногда даже уникальные под каждую вакансию).
➖ Заполняет анкеты, проходит тесты.

Все эти действия отнимают время, но не приводят к результату.

Почему это не работает?

HR-менеджер не может вручную отсмотреть 2000 откликов, оценить каждое резюме и прочитать сопроводительные письма. Поэтому компании используют ATS-системы (системы автоматического подбора), которые анализируют резюме и определяют процент его соответствия вакансии.

Что делать, чтобы повысить шансы?

1️⃣ Добавить ключевые навыки в резюме — и в основной текст, и в теги. Возьмите их с easyoffer.ru

2️⃣ Убрать нерелевантный опыт, оставить только подходящий.

3️⃣ Оформить опыт так, чтобы он выглядел релевантным. Если у вас его нет, укажите проекты, стажировки или другой опыт, который можно представить как работу от 1 года. Если опыт слишком большой, сузьте его до 6 лет.

4️⃣ Откликаться на все вакансии без разбору. Если вы Junior, не ищите только стажер или Junior-вакансии — пробуйте везде. Не отказывайте себе сами, пусть это решит HR

5️⃣ Сделать резюме публичным, потому что HR-менеджеры часто ищут кандидатов не только среди откликов, но и в базе резюме.

6️⃣ Используйте ИИ по минимуму – ATS-системы считывают это и помечают "сгенерировано ИИ"

‼️ Главное правило: чем больше откликов — тем выше шанс получить оффер. Делайте резюме удобным для ATS-систем, и вас заметят.

1. Посмотрите видео о том как я вывел свою резюме в Топ1 на HH
2. Посмотрите видео как я нашел первую работу
3. Прочитайте этот кейс про оптимизацию резюме

Если прям вообще тяжело.

Создайте несколько разных резюме. Создайте 2, 3 да хоть 10 резюме. Настройте авто-отлики и ждите приглашения на собесы.

Не нужно создавать иллюзию поиска работы, сделайте несколько простых и актуальных действий.

🤔 Зачем нужен Prometheus?

Это система мониторинга и оповещения с открытым исходным кодом, разработанная для сбора и анализа метрик с серверов, приложений и других компонентов инфраструктуры.

🚩Почему нужен Prometheus?

🟠Мониторинг состояния системы
позволяет отслеживать производительность, загрузку CPU, память, сетевой трафик и другие параметры.
🟠Автоматический сбор метрик
использует модель pull (запрашивает данные у сервисов), а не push (как, например, Graphite). Это удобнее для управления и отказоустойчивости.
🟠Гибкость в сборе данных
поддерживает кастомные метрики, которые можно интегрировать в своё приложение.
🟠Продвинутая система алертинга
позволяет настроить уведомления при достижении критических значений.
🟠Хранение исторических данных
помогает анализировать тренды и предсказывать возможные сбои.
🟠Масштабируемость
легко развертывается в облаке, Kubernetes, Docker и других средах.

🚩Как работает Prometheus?

🟠Экспортеры метрик
собирают данные.
🟠Prometheus
опрашивает эти экспортеры по HTTP (pull-модель).
🟠PromQL
(язык запросов) используется для анализа данных.
🟠Grafana
или другие инструменты визуализируют метрики.
🟠Alertmanager
отправляет уведомления (Slack, Email, Telegram и др.).

🚩Пример использования в Go-приложении

Для интеграции в Go-приложение можно использовать пакет prometheus/client_golang

package main

import (
  "net/http"
  "github.com/prometheus/client_golang/prometheus"
  "github.com/prometheus/client_golang/prometheus/promhttp"
)

var httpRequests = prometheus.NewCounter(
  prometheus.CounterOpts{
    Name: "http_requests_total",
    Help: "Total number of HTTP requests",
  },
)

func handler(w http.ResponseWriter, r *http.Request) {
  httpRequests.Inc() // Увеличиваем счетчик запросов
  w.Write([]byte("Hello, Prometheus!"))
}

func main() {
  // Регистрируем метрику
  prometheus.MustRegister(httpRequests)

  // Эндпоинт для сбора метрик
  http.Handle("/metrics", promhttp.Handler())
  http.HandleFunc("/", handler)

  http.ListenAndServe(":8080", nil)
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие типы мьютексов предоставляет stdlib?

1. sync.Mutex:
- Базовый мьютекс для блокировки доступа к разделяемым данным.
2. sync.RWMutex:
- Поддерживает несколько потоков чтения одновременно, но блокирует запись.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое структура (stuct) в Go Зачем они нужны?

Структуры (struct) представляют собой агрегированные типы данных, которые позволяют объединять несколько различных типов данных под одним именем. Они служат для моделирования объектов и хранения связанных данных, предоставляя удобный способ управления сложными данными.

🚩Определение структуры

Определяются с использованием ключевого слова struct. В структуре могут быть поля различных типов.

package main

import "fmt"

// Определение структуры Person
type Person struct {
    Name string
    Age  int
}

func main() {
    // Создание экземпляра структуры
    var p Person
    p.Name = "Alice"
    p.Age = 30

    fmt.Println("Name:", p.Name)
    fmt.Println("Age:", p.Age)
}

🚩Инициализация структур

Существует несколько способов инициализации структур.

package main

import "fmt"

// Определение структуры Person
type Person struct {
    Name string
    Age  int
}

func main() {
    // Инициализация с использованием литерала структуры
    p := Person{Name: "Bob", Age: 25}
    fmt.Println("Name:", p.Name)
    fmt.Println("Age:", p.Age)
}

Инициализация по умолчанию

package main

import "fmt"

// Определение структуры Person
type Person struct {
    Name string
    Age  int
}

func main() {
    // Инициализация по умолчанию (поля будут нулевыми значениями)
    var p Person
    fmt.Println("Name:", p.Name) // Пустая строка
    fmt.Println("Age:", p.Age)   // 0
}

🚩Вложенные структуры

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

package main

import "fmt"

// Определение структур Address и Person
type Address struct {
    City  string
    State string
}

type Person struct {
    Name    string
    Age     int
    Address Address
}

func main() {
    // Инициализация структуры с вложенной структурой
    p := Person{
        Name: "Charlie",
        Age:  40,
        Address: Address{
            City:  "New York",
            State: "NY",
        },
    }

    fmt.Println("Name:", p.Name)
    fmt.Println("Age:", p.Age)
    fmt.Println("City:", p.Address.City)
    fmt.Println("State:", p.Address.State)
}

🚩Методы структур

Могут быть ассоциированы со структурами, что позволяет добавлять функциональность к структурам.

package main

import "fmt"

// Определение структуры Person
type Person struct {
    Name string
    Age  int
}

// Метод для структуры Person
func (p Person) Greet() {
    fmt.Printf("Hello, my name is %s and I am %d years old.\n", p.Name, p.Age)
}

func main() {
    p := Person{Name: "David", Age: 35}
    p.Greet()
}

🟠Организация данных
Позволяют логически объединять связанные данные в один тип.
🟠Моделирование объектов
Позволяют моделировать реальные объекты и их свойства.
🟠Повышение читаемости и поддерживаемости кода
Использование структур делает код более организованным и понятным.
🟠Методы и функциональность
Могут иметь методы, что позволяет добавлять функциональность и поведение объектам.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как тесты и TDD влияют на организацию кода?

1. Четкость структуры:
- Код становится модульным и более читаемым.
2. Меньшая связность:
- Компоненты проектируются так, чтобы их можно было легко тестировать независимо.
3. Предсказуемость изменений:
- Тесты помогают выявлять ошибки при рефакторинге.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Безопасен ли map?

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

🚩Почему карты в Go не потокобезопасны

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

🟠Состояния гонки
Одновременный доступ к карте из нескольких горутин может привести к состояниям гонки, когда порядок выполнения операций непредсказуем.
🟠Паники
Одновременное изменение структуры карты, например добавление или удаление элементов, может вызвать панику в программе.

🚩Подходы к обеспечению потокобезопасности

🟠Мьютексы (Mutex)
Самый распространенный способ синхронизации доступа к карте — использование sync.Mutex. Мьютексы позволяют заблокировать доступ к карте на время чтения или записи.

package main

import (
    "fmt"
    "sync"
)

func main() {
    var mu sync.Mutex
    m := make(map[string]int)
    var wg sync.WaitGroup

    write := func(key string, value int) {
        mu.Lock()
        m[key] = value
        mu.Unlock()
    }

    read := func(key string) int {
        mu.Lock()
        defer mu.Unlock()
        return m[key]
    }

    wg.Add(2)
    go func() {
        defer wg.Done()
        write("key1", 42)
    }()
    go func() {
        defer wg.Done()
        fmt.Println(read("key1"))
    }()
    wg.Wait()
}

🟠RWMutex
Если в вашей программе чаще происходят операции чтения, чем записи, можно использовать sync.RWMutex, который позволяет нескольким горутинам читать данные одновременно, но обеспечивает эксклюзивный доступ для записи.

package main

import (
    "fmt"
    "sync"
)

func main() {
    var mu sync.RWMutex
    m := make(map[string]int)
    var wg sync.WaitGroup

    write := func(key string, value int) {
        mu.Lock()
        m[key] = value
        mu.Unlock()
    }

    read := func(key string) int {
        mu.RLock()
        defer mu.RUnlock()
        return m[key]
    }

    wg.Add(2)
    go func() {
        defer wg.Done()
        write("key1", 42)
    }()
    go func() {
        defer wg.Done()
        fmt.Println(read("key1"))
    }()
    wg.Wait()
}

🟠sync.Map
Go предоставляет специальную структуру sync.Map, которая изначально создана для безопасного использования в многопоточной среде. Она автоматически обеспечивает синхронизацию операций.

package main

import (
    "fmt"
    "sync"
)

func main() {
    var m sync.Map
    var wg sync.WaitGroup

    wg.Add(2)
    go func() {
        defer wg.Done()
        m.Store("key1", 42)
    }()
    go func() {
        defer wg.Done()
        value, _ := m.Load("key1")
        fmt.Println(value)
    }()
    wg.Wait()
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чём разница между сцеплением и связанностью?

1. Сцепление (Coupling):
- Мера зависимости между модулями. Сильное сцепление усложняет изменения и тестирование.
2. Связанность (Cohesion):
- Насколько элементы внутри модуля связаны логически. Высокая связанность означает, что модуль выполняет одну задачу.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие есть возможности у создания дочернего контекста данных?

Создание дочернего контекста данных в Go предоставляет мощные возможности для управления временем выполнения операций, отмены и передачи метаданных.

🟠Управление временем выполнения операций
Контексты позволяют задавать дедлайны и таймауты для операций.
context.WithTimeout создает контекст с таймаутом, после которого операция будет автоматически отменена.

ctx, cancel := context.WithTimeout(parentCtx, 2*time.Second)
defer cancel()

context.WithDeadline создает контекст с дедлайном, который определяет точное время, после которого операция будет отменена.

deadline := time.Now().Add(5 * time.Second)
ctx, cancel := context.WithDeadline(parentCtx, deadline)
defer cancel()

🟠Явная отмена операций
Контексты позволяют явно отменять операции, что полезно для управления горутинами и предотвращения утечек памяти.
context.WithCancel создает контекст, который может быть отменен вручную с помощью функции cancel.

ctx, cancel := context.WithCancel(parentCtx)
defer cancel()

🟠Передача метаданных
Контексты позволяют передавать данные между функциями, что полезно для передачи информации о запросах, пользователей и других данных.
context.WithValue создает контекст, который содержит пару ключ-значение для передачи метаданных.

type key string
ctx := context.WithValue(parentCtx, key("userID"), 12345)

🟠Вложенные контексты
Можно создавать иерархии контекстов, где каждый дочерний контекст наследует отмену и дедлайны от родительского.
Создание вложенных контекстов позволяет строить гибкие и сложные системы управления временем выполнения и отмены.

ctx1, cancel1 := context.WithCancel(parentCtx)
ctx2, cancel2 := context.WithTimeout(ctx1, 1*time.Second)
defer cancel1()
defer cancel2()

🟠Синхронизация горутин
Контексты обеспечивают механизм для синхронизации и координации работы нескольких горутин.
Пример синхронизации горутин

var wg sync.WaitGroup
ctx, cancel := context.WithCancel(parentCtx)
defer cancel()

wg.Add(2)
go func() {
    defer wg.Done()
    worker(ctx, "Worker 1")
}()
go func() {
    defer wg.Done()
    worker(ctx, "Worker 2")
}()
wg.Wait()

func worker(ctx context.Context, name string) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println(name, "stopped")
            return
        default:
            fmt.Println(name, "working")
            time.Sleep(1 * time.Second)
        }
    }
}

🟠Управление жизненным циклом запросов
Контексты широко используются в веб-серверах для управления жизненным циклом HTTP-запросов, обеспечивая таймауты и отмену при завершении обработки запросов.
Пример использования контекста в обработчике HTTP-запроса

func handler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    select {
    case <-time.After(5 * time.Second):
        fmt.Fprintln(w, "Request processed")
    case <-ctx.Done():
        err := ctx.Err()
        http.Error(w, err.Error(), http.StatusInternalServerError)
    }
}

http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)

Ставь 👍 и забирай 📚 Базу знаний

🤔 Почему в TDD тесты пишутся прежде кода?

1. Четкость требований:
- Тесты помогают лучше понять, что должен делать код.
2. Минимизация ошибок:
- Код пишется для прохождения тестов, что снижает вероятность багов.
3. Улучшение дизайна:
- Код проектируется так, чтобы быть тестируемым и модульным.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний