💬 Для каких целей в Go может использоваться пустая структура?

☑️ Пустая структура (struct{}{}) не занимает места в памяти. Это делает её идеальной для создания коллекций, где важны только ключи, а значения не нужны.

// Использование для уникального набора значений (set)
uniqueSet := make(map[string]struct{})
uniqueSet["value1"] = struct{}{}
// Проверка наличия значения
_, exists := uniqueSet["value1"]

☑️ Пустые структуры часто используются в каналах для передачи сигналов. Это полезно для синхронизации горутин или передачи сигналов без передачи данных.

done := make(chan struct{})
go func() {
    // ...
    done <- struct{}{} // Отправка сигнала о завершении
}()
<-done // Ожидание сигнала

☑️ Иногда пустые структуры используются как маркеры в сложных структурах данных или для реализации определённых паттернов проектирования, таких как Singleton или Null Object.

type Singleton struct{}

func (s Singleton) DoSomething() {
    // Реализация метода
}

var instance Singleton
instance.DoSomething()

💬 Почему для использования горутин в Go не требуется помечать родительскую функцию как async, в отличие от некоторых других C-подобный ЯП?

Горутины в Go используются для реализации конкурентности, и их работа базируется на модели «‎общих каналов» вместо «‎общих данных». Это ключевое отличие от моделей асинхронного программирования, используемых в других языках, похожих на C.

В Go, при вызове функции с ключевым словом go, рантайм автоматически запускает эту функцию в новой горутине, позволяя ей выполняться конкурентно относительно вызывающего кода.

Это отличается от модели, используемой в языках, где async/await используется для явного указания асинхронного выполнения. В Go, всё управление горутинами и их взаимодействие скрыто от разработчика и обрабатывается рантаймом, что упрощает работу с конкурентным кодом.

💬 Какие изменения коснулись цикла for в Go 1.22?

1. Изменение в поведении переменных цикла: в Go 1.21 и ранее, переменные, объявленные в цикле for, создавались один раз и обновлялись при каждой итерации. Это могло привести к ошибкам, когда одна и та же переменная использовалась в замыканиях. Например:

var funcs []func()
for i := 0; i < 3; i++ {
    funcs = append(funcs, func() { fmt.Println(i) })
}
for _, f := range funcs {
    f() // Выводит "3" три раза, так как все функции ссылаются на одну и ту же переменную i.
}

В Go 1.22, каждая итерация цикла создает новые переменные:

var funcs []func()
for i := 0; i < 3; i++ {
    funcs = append(funcs, func(i int) func() {
        return func() { fmt.Println(i) }
    }(i))
}
for _, f := range funcs {
    f() // Выводит "0", "1", "2", так как каждая функция ссылается на свою копию переменной i.
}

2. Циклы for теперь могут итерировать по целым числам: в Go 1.22 добавлена возможность использовать циклы for для итерации по диапазону целых чисел. Например:

package main

import "fmt"

func main() {
    for i := range 10 {
        fmt.Println(10 - i) // Выводит числа от 10 до 1.
    }
}

В этом примере цикл for используется для итерации по целым числам от 0 до 9, и на каждой итерации выводится число, равное 10 минус текущее значение итератора.

💬 В чем разница между массивами C и срезами Go?

📌 Массивы в C:

1. Статический размер: в C размер массива должен быть известен во время компиляции и не может изменяться во время выполнения. Это означает, что массивы в C являются статическими.

2. Прямой доступ к памяти: массивы в C представляют собой непрерывный блок памяти. Элементы массива хранятся в памяти последовательно, и доступ к ним осуществляется напрямую через указатели и арифметику указателей.

3. Размер и тип: в C размер массива является частью его типа, что означает, что массивы разного размера представляют разные типы данных.

📌 Срезы в Go:

1. Динамический размер: срезы в Go представляют собой динамические, гибкие представления массивов. Срезы могут изменять свой размер во время выполнения, что делает их более гибкими по сравнению с массивами в C.

2. Абстракция над массивами: срез в Go представляет собой структуру, содержащую три компонента: указатель на массив, длину и емкость. Это позволяет срезам предоставлять дополнительную безопасность и удобство по сравнению с прямым использованием массивов.

3. Управление памятью: в Go управление памятью для срезов осуществляется автоматически с помощью сборщика мусора. Это уменьшает риск ошибок, связанных с утечками памяти и неправильным управлением ресурсами.

4. Встроенные функции: в Go существуют встроенные функции для работы со срезами.

📌 Основное отличие между массивами в C и срезами в Go заключается в их гибкости и управлении памятью. Массивы в C статичны и требуют более тщательного управления памятью, в то время как срезы в Go предлагают динамическую структуру с автоматическим управлением памятью и дополнительными удобными функциями для работы с данными.

💬 Каким образом расширяется стек горутины в Go?

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

Процесс расширения стека начинается с обнаружения, что текущий стек горутины полностью заполнен. В этот момент Go выделяет новый стек, размер которого обычно в два раза больше предыдущего. Затем содержимое старого стека копируется в новый, увеличенный стек.

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

👉 Подробнее

💬 Какие проблемы синхронизации могут возникнуть в программе на Go?

• Data race: две или более горутины одновременно обращаются к одной ячейке памяти без какой-либо синхронизации и как минимум одна из них осуществляет запись.

• Deadlock: две или более горутин ожидают друг друга, освобождая ресурсы, и таким образом ни одна из них не может продолжить выполнение.

• Starvation: одна или несколько горутин никогда не получают доступ к ресурсу или к выполнению, потому что другие горутины постоянно захватывают доступ.

• Livelock: горутины активно выполняют операции, но эти операции не приближают их к завершению задачи. Часто это связано с попытками избежать deadlock, которые приводят к бесконечному циклу.

💬 Какие изменения коснулись паттернов HTTP-роутинга в стандартной библиотеке Go 1.22?

☑️ Теперь можно регистрировать обработчики для конкретных HTTP-методов, что ограничивает вызовы обработчика только запросами с указанным методом. Паттерны с методами имеют приоритет над соответствующими без метода.

☑️ Паттерны с подстановочными знаками, например /items/{id}, поддерживают сегменты URL-пути. Значение сегмента доступно через метод Request.PathValue. Паттерны, оканчивающиеся на ..., соответствуют всем оставшимся сегментам.

☑️ Паттерны, оканчивающиеся на /, соответствуют всем путям с этим префиксом, а для точного соответствия, включая конечный слэш, используется {$}.

☑️ Если паттерны пересекаются, более конкретный имеет приоритет. Нарушения обратной совместимости контролируются полем GODEBUG httpmuxgo121.

👉 Подробнее

🧑‍💻 Статьи для IT: как объяснять и распространять значимые идеи

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

Что: семь модулей, посвященных написанию, редактированию, иллюстрированию и распространению публикаций.

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

👉Материалы регулярно дополняются, обновляются и корректируются. А еще мы отвечаем на все учебные вопросы в комментариях курса.

💬 Что из себя представляет Compare and swap в Go?

Compare-and-swap (CAS) в Go — это атомарная операция, которая используется для достижения синхронизации. Она проверяет значение некоторой переменной и, если оно соответствует ожидаемому, заменяет его на новое значение. Важной особенностью CAS является то, что весь процесс выполнения — сравнение и замена — атомарен, то есть не может быть прерван или нарушен другими потоками или горутинами.

В Go для работы с атомарными операциями, включая CAS, используется пакет sync/atomic. Примером CAS операции в Go является функция atomic.CompareAndSwapInt32 или atomic.CompareAndSwapInt64.

Эти функции принимают три аргумента: указатель на переменную, старое значение и новое значение. Функция сначала сравнивает текущее значение переменной со старым значением, и если они совпадают, заменяет его на новое значение. Возвращаемое значение — булево, указывающее, была ли произведена замена.

📌 Пример использования atomic.CompareAndSwapInt32:

var value int32 = 100
newValue := int32(200)
oldValue := int32(100)

swapped := atomic.CompareAndSwapInt32(&value, oldValue, newValue)
if swapped {
    fmt.Println("Значение было заменено")
} else {
    fmt.Println("Значение не было заменено")
}

В этом примере, если начальное значение переменной value равно oldValue (100), то оно будет атомарно заменено на newValue (200).

💬 Что означает термин Stop-the-world в контексте сборки мусора?

Stop-the-world в контексте сборки мусора означает период, когда выполнение программы полностью останавливается, чтобы сборщик мусора мог освободить неиспользуемую память и устранить утечки памяти.

Что касается Go, то GC выполняет бо́льшую часть работы одновременно с приложением, чтобы уменьшить задержки. Это делается для оптимизации как времени отклика (например, задержки веб-запросов), так и пропускной способности приложения.

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

Самые полезные каналы для программистов в одной подборке!

Сохраняйте себе, чтобы не потерять 💾

🔥Для всех

Библиотека программиста — новости, статьи, досуг, фундаментальные темы
Книги для программистов
IT-мемы
Proglib Academy — тут мы рассказываем про обучение и курсы

#️⃣C#

Книги для шарпистов | C#, .NET, F#
Библиотека шарписта — полезные статьи, новости и обучающие материалы по C#
Библиотека задач по C# — код, квизы и тесты
Библиотека собеса по C# — тренируемся отвечать на каверзные вопросы во время интервью и технического собеседования
Вакансии по C#, .NET, Unity Вакансии по PHP, Symfony, Laravel

☁️DevOps

Библиотека devops’а — полезные статьи, новости и обучающие материалы по DevOps
Вакансии по DevOps & SRE
Библиотека задач по DevOps — код, квизы и тесты
Библиотека собеса по DevOps — тренируемся отвечать на каверзные вопросы во время интервью и технического собеседования

🐘PHP

Библиотека пхпшника — полезные статьи, новости и обучающие материалы по PHP
Вакансии по PHP, Symfony, Laravel
Библиотека PHP для собеса — тренируемся отвечать на каверзные вопросы во время интервью и технического собеседования
Библиотека задач по PHP — код, квизы и тесты

🐍Python

Библиотека питониста — полезные статьи, новости и обучающие материалы по Python
Вакансии по питону, Django, Flask
Библиотека Python для собеса — тренируемся отвечать на каверзные вопросы во время интервью и технического собеседования
Библиотека задач по Python — код, квизы и тесты

☕Java

Библиотека джависта — полезные статьи по Java, новости и обучающие материалы
Библиотека Java для собеса — тренируемся отвечать на каверзные вопросы во время интервью и технического собеседования
Библиотека задач по Java — код, квизы и тесты
Вакансии для java-разработчиков

👾Data Science

Книги для дата сайентистов | Data Science
Библиотека Data Science — полезные статьи, новости и обучающие материалы по Data Science
Библиотека Data Science для собеса — тренируемся отвечать на каверзные вопросы во время интервью и технического собеседования
Библиотека задач по Data Science — код, квизы и тесты
Вакансии по Data Science, анализу данных, аналитике, искусственному интеллекту

🦫Go

Книги для Go разработчиков
Библиотека Go разработчика — полезные статьи, новости и обучающие материалы по Go
Библиотека Go для собеса — тренируемся отвечать на каверзные вопросы во время интервью и технического собеседования
Библиотека задач по Go — код, квизы и тесты
Вакансии по Go

🧠C++

Книги для C/C++ разработчиков
Библиотека C/C++ разработчика — полезные статьи, новости и обучающие материалы по C++
Библиотека C++ для собеса — тренируемся отвечать на каверзные вопросы во время интервью и технического собеседования
Библиотека задач по C++ — код, квизы и тесты
Вакансии по C++

💻Другие профильные каналы

Библиотека фронтендера
Библиотека мобильного разработчика
Библиотека хакера
Библиотека тестировщика

💼Каналы с вакансиями

Вакансии по фронтенду, джаваскрипт, React, Angular, Vue
Вакансии для мобильных разработчиков
Вакансии по QA тестированию
InfoSec Jobs — вакансии по информационной безопасности

📁Чтобы добавить папку с нашими каналами, нажмите 👉сюда👈

🤖Также у нас есть боты:
Бот с IT-вакансиями
Бот с мероприятиями в сфере IT

Мы в других соцсетях:
🔸VK
🔸YouTube
🔸Дзен
🔸Facebook *
🔸Instagram *

* Организация Meta запрещена на территории РФ

💬 Как обрабатывать ошибки сетевых соединений в Go?

В Go обработка ошибок сетевых соединений основана на принципе явной проверки возвращаемых ошибок. После каждого вызова сетевых функций (Dial, Listen, Accept и других) важно проверять возвращаемый объект ошибки. Если ошибка не равна nil, принимаем соотвествующие меры в зависимости от задач программы.

Для корректной обработки сценариев прерывания соединений и тайм-аутов в Go, можно использовать контекст и настроить тайм-ауты для сетевых операций:

☑️ Для установления соединения с тайм-аутом можно использовать DialContext из пакета net. Это позволяет указать контекст с тайм-аутом, автоматически прерывающим соединение по истечении указанного времени.

☑️ Можно также устанавливать тайм-ауты напрямую на сокете после его создания. Функции SetReadDeadline и SetWriteDeadline позволяют установить тайм-ауты для операций чтения и записи соответственно.

Простой пример, демонстрирующий использование контекста и тайм-аута:

package main

import (
    "context"
    "fmt"
    "net"
    "time"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    conn, err := net.DialContext(ctx, "tcp", "google.com:80")
    if err != nil {
        fmt.Printf("Ошибка соединения: %s\n", err)
        return
    }
    defer conn.Close()

    // Устанавливаем тайм-ауты для операций чтения/записи
    deadline := time.Now().Add(2 * time.Second)
    conn.SetReadDeadline(deadline)
    conn.SetWriteDeadline(deadline)

    // Остальная часть кода для чтения/записи
}

Контекст с тайм-аутом в 5 секунд используется для установления соединения, а дедлайны для чтения и записи установлены в 2 секунды после установления соединения.

💬 Для чего предназначен пакет errgroup и какие основные кейсы его использования?

Пакет errgroup в Go предназначен для упрощения работы с группами горутин, особенно при выполнении задач, которые могут генерировать ошибки.

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

📌 Основные особенности:

☑️ Обработка ошибок в горутинах: errgroup позволяет автоматически захватывать первую ошибку, возникающую в любой из горутин в группе. Это упрощает управление ошибками при работе с множеством конкурентных операций.

☑️ Синхронизация завершения горутин: errgroup позволяет дождаться завершения всех горутин в группе перед продолжением выполнения основной программы. Это обеспечивает синхронизацию между конкурентными задачами.

☑️ Контекст с отменой: errgroup работает с пакетом context для обеспечения механизмов отмены. Если одна из горутин в группе возвращает ошибку, все остальные горутины получают сигнал об отмене через контекст.

📌 Примеры юзкейсов:

☑️ Конкурентные HTTP-запросы: если нам нужно выполнить несколько HTTP-запросов конкурентно и обработать ошибки, возникающие при выполнении любого из запросов.

☑️ Обработка данных из нескольких источников: например, когда необходимо агрегировать данные из разных баз данных или сервисов одновременно.

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

🏃 Самоучитель по Go для начинающих. Часть 7. Массивы и слайсы. Append и сopy. Пакет slices

Рассмотрим реализацию массивов и слайсов в языке Go, разберем функции append и copy, изучим пакет slices и по традиции решим несколько занимательных задач.

👉 Читать статью
👉 Часть 1
👉 Часть 2
👉 Часть 3
👉 Часть 4
👉 Часть 5
👉 Часть 6

💬 Что из себя представляет контекст и состояние горутины в Go?

📌 В Go, каждая горутина имеет свой контекст и состояние:

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

▪️Состояние горутины описывает её текущее поведение в системе. Горутина может быть в одном из нескольких состояний: выполняется, готова к выполнению, заблокирована (например, ожидает ввода-вывода или блокировки), спящая или завершена. Планировщик Go управляет переходом горутин между этими состояниями для эффективного распределения ресурсов процессора.

💬 Чем отличается параллельное и конкурентное исполнение кода в Go?

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

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

👉 Подробнее

💬 В чем смысл понятий CPU-bound и IO-bound workloads?

📌 Существует два типа workloads, которые важно понимать при рассмотрении конкурентности в Go:

🔸 CPU-bound описывает задачи или программы, скорость выполнения которых ограничена скоростью процессора. То есть улучшение производительности достигается увеличением мощности или эффективности ЦПУ. Примерами CPU-bound задач являются сложные вычисления и обработка данных.

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

💬 Как работает механизм пула соединений в Go и для чего он используется?

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

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

🔸 Инициализация пула соединений: сначала мы инициализируем пул соединений, создавая и сохраняя набор соединений с целевым сервисом. Количество соединений в пуле может быть фиксированным или настраиваемым в зависимости от юзкейса.
🔸 Запрос соединения: когда приложению нужно установить соединение с сервисом, оно запрашивает свободное соединение из пула. Если в пуле есть доступные соединения, оно возвращает одно из них.
🔸 Использование соединения: получив свободное соединение, мы можем использовать его для выполнения запросов или операций с сервисом, например, для выполнения SQL-запросов к БД.
🔸 Возврат соединения в пул: после завершения операции соединение возвращается в пул, а не закрывается. Это позволяет использовать соединение повторно для будущих запросов, вместо создания нового.
🔸 Управление состоянием соединений: пул соединений может отслеживать состояние каждого соединения, чтобы убедиться, что все они готовы к использованию. Если соединение становится недоступным (например, из-за сбоя в коммуникации), оно может быть восстановлено или заменено новым.

📌 Преимущества использования механизма пула соединений в Go:

🔸 Экономия ресурсов: пул соединений снижает накладные расходы на установление и закрытие соединений, экономя ресурсы сервера и сети.
🔸 Улучшение производительности: повторное использование соединений уменьшает задержки, связанные с установлением новых соединений, повышая производительность приложения.
🔸 Контроль над количеством соединений: мы можем легко управлять количеством активных соединений, чтобы избежать перегрузки сервера.
🔸 Обработка ошибок: механизм пула соединений может автоматически обнаруживать и восстанавливать некорректные или разорванные соединения.

📌 Примеры библиотек и фреймворков в Go, предоставляющих механизмы пула соединений для различных типов сервисов, включают database/sql для баз данных, net/http для HTTP-соединений и сторонние библиотеки для других типов соединений.

💬 В чем суть принципа Dependency Inversion в Go?

Dependency Inversion Principle, DIP — это один из пяти принципов SOLID, который описывает, как организовать зависимости между компонентами.

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

📌 Допустим, у нас есть приложение, которое отправляет уведомления.

🔸 Неправильный способ без использования DIP:

package main

import "fmt"

// Модуль низкого уровня
type EmailSender struct{}

func (es *EmailSender) SendEmail(message string) {
    fmt.Printf("Sending email: %s\n", message)
}

// Модуль высокого уровня
type NotificationService struct {
    emailSender *EmailSender
}

func NewNotificationService() *NotificationService {
    return &NotificationService{emailSender: &EmailSender{}}
}

func (ns *NotificationService) SendNotification(message string) {
    ns.emailSender.SendEmail(message)
}

func main() {
    notificationService := NewNotificationService()
    notificationService.SendNotification("Hello, world!")
}

В этом примере модуль высокого уровня NotificationService напрямую зависит от модуля низкого уровня EmailSender, что нарушает DIP.

🔸 Правильный способ с использованием DIP:

package main

import "fmt"

// Абстракция (интерфейс)
type MessageSender interface {
    Send(message string)
}

// Модуль низкого уровня
type EmailSender struct{}

func (es *EmailSender) Send(message string) {
    fmt.Printf("Sending email: %s\n", message)
}

// Модуль высокого уровня
type NotificationService struct {
    messageSender MessageSender
}

func NewNotificationService(ms MessageSender) *NotificationService {
    return &NotificationService{messageSender: ms}
}

В примере модуль высокого уровня NotificationService зависит от MessageSender.