🤔 Какие преимущества у горутин над тредами?

1. Легковесность – горутины потребляют меньше памяти, чем системные потоки.
2. Планировщик Go – позволяет управлять миллионами горутин без явного управления потоками.
3. Простота работы с конкурентностью – нет необходимости использовать mutex для синхронизации, благодаря каналам.
4. Низкие затраты на переключение контекста – переключение между горутинами быстрее, чем между потоками.

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

🤔 Зачем синхронизировать доступ данных?

В многопоточных (параллельных) программах горутины (goroutines) могут одновременно изменять одни и те же данные. Если не синхронизировать доступ, это приведёт к гонке данных (data race), когда несколько потоков читают/пишут одно и то же значение одновременно.

🚩`sync.Mutex` (мьютексы — блокировка данных)

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

package main

import (
  "fmt"
  "sync"
)

var (
  counter int
  mutex   sync.Mutex
)

func increment(wg *sync.WaitGroup) {
  defer wg.Done()
  mutex.Lock()   // Блокируем доступ
  counter++      // Изменяем данные
  mutex.Unlock() // Разблокируем доступ
}

func main() {
  var wg sync.WaitGroup

  for i := 0; i < 1000; i++ {
    wg.Add(1)
    go increment(&wg)
  }

  wg.Wait()
  fmt.Println("Итоговый счетчик:", counter) // 1000
}

🚩`sync.RWMutex` (разделяемая блокировка)

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

var (
  data  int
  mutex sync.RWMutex
)

func readData(wg *sync.WaitGroup) {
  defer wg.Done()
  mutex.RLock() // Разрешаем чтение
  fmt.Println("Читаем данные:", data)
  mutex.RUnlock()
}

func writeData(wg *sync.WaitGroup) {
  defer wg.Done()
  mutex.Lock() // Блокируем на запись
  data++
  mutex.Unlock()
}

🚩`sync.WaitGroup` (ожидание горутин)

Позволяет дождаться завершения всех горутин без блокировки данных.

var wg sync.WaitGroup

wg.Add(2)   // Ожидаем 2 горутины
go func() {
  defer wg.Done()
  fmt.Println("Горутина 1 завершилась")
}()
go func() {
  defer wg.Done()
  fmt.Println("Горутина 2 завершилась")
}()

wg.Wait()  // Ждём завершения всех горутин
fmt.Println("Все горутины завершены")

🚩`sync/atomic` (атомарные операции)

Атомарные операции быстрее мьютексов и гарантируют безопасное обновление переменных без гонок данных.

import "sync/atomic"

var counter int64

func incrementAtomic() {
  atomic.AddInt64(&counter, 1) // Атомарное увеличение
}

🚩Каналы (лучший способ в Go)

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

package main

import "fmt"

func main() {
  ch := make(chan int) // Канал для передачи данных

  go func() {
    ch <- 42 // Отправляем данные
  }()

  data := <-ch // Получаем данные
  fmt.Println("Получено:", data)
}

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

🤔 Какие есть недостатки у горутин относительно тредов?

1. Отсутствие привязки к конкретному ядру – горутины исполняются планировщиком Go, а не напрямую ОС.
2. Необходимость контроля за утечками – забытые горутины продолжают выполняться, потребляя ресурсы.
3. Ограниченная поддержка системных вызовов – при блокирующих операциях Go может выделять новый поток ОС.

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

🤔 Как слайсы работают?

Слайс (slice) — это динамический массив, который ссылается на часть массива в памяти. В отличие от массивов (array), слайсы могут изменять размер.

🚩Внутреннее устройство слайса

Слайс в Go — это структура

type SliceHeader struct {
    Data uintptr // Указатель на массив в памяти
    Len  int     // Длина слайса (количество элементов)
    Cap  int     // Вместимость (capacity) — сколько элементов может вместить без перевыделения памяти
}

Пример структуры слайса

arr := [5]int{1, 2, 3, 4, 5}
s := arr[1:4] // Берём срез от 2-го до 4-го элемента
fmt.Println(s) // [2 3 4]

🚩Создание слайсов

Есть несколько способов создать слайс:
Способ 1: Срез массива

arr := [5]int{10, 20, 30, 40, 50}
s := arr[1:4] // [20 30 40]

Способ 2: Использование make()

s := make([]int, 3, 5) // Длина 3, вместимость 5
fmt.Println(s, len(s), cap(s)) // [0 0 0] 3 5

Способ 3: Литерал (инициализация значениями)

s := []int{1, 2, 3}
fmt.Println(s) // [1 2 3]

🚩Изменение слайса

Слайсы можно изменять, используя append().

s := []int{1, 2, 3}
s = append(s, 4, 5)
fmt.Println(s) // [1 2 3 4 5]

🚩Как растёт `slice`?

Когда append() увеличивает slice, Go использует оптимизированный алгоритм роста:
- Если cap < 1024, слайс удваивает размер (cap *= 2).
- Если cap >= 1024, рост идёт примерно на 25% (cap += cap / 4).

s := []int{}
for i := 0; i < 10; i++ {
    s = append(s, i)
    fmt.Printf("Len: %d, Cap: %d\n", len(s), cap(s))
}

Выход (пример)

Len: 1, Cap: 1
Len: 2, Cap: 2
Len: 3, Cap: 4
Len: 5, Cap: 8
Len: 9, Cap: 16

🚩Как избежать неожиданных эффектов?

Так как слайсы хранят ссылку на массив, возможны побочные эффекты.

arr := [5]int{1, 2, 3, 4, 5}
s1 := arr[:3] // [1 2 3]
s2 := arr[2:] // [3 4 5]
s2[0] = 100    // Меняем первый элемент s2

fmt.Println(s1) // [1 2 100] ❗️ s1 тоже изменился

Решение: используйте copy() для создания нового массива.

s1 := []int{1, 2, 3}
s2 := make([]int, len(s1))
copy(s2, s1) // Копируем данные
s2[0] = 100
fmt.Println(s1) // [1 2 3] ✅ Оригинал не изменился

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

🤔 Что можно делать с закрытым каналом?

- Читать данные, пока буфер не станет пустым.
- Использовать range, чтобы получить оставшиеся элементы.
- Проверять закрытие с помощью второго параметра (ok).
Записывать в закрытый канал нельзя – это приведет к panic.

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

🤔 Как устроены контексты в Go?

Контексты (context.Context) представляют собой интерфейс, который используется для передачи мета-данных, управления сроками действия и отменой операций в иерархии вызовов функций. Основная цель контекста — обеспечение способа для остановки выполнения программы (например, запросов или подпроцессов) по требованию. Это особенно полезно в сетевых приложениях, где вам может потребоваться прервать выполнение операции, которая больше не требуется или занимает слишком много времени.

🚩Ключевые особенности

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

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

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

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

🚩Создание и использование контекста

🟠context.Background()
Возвращает пустой контекст, который никогда не отменяется. Обычно используется в основной функции и при инициализации.

🟠context.TODO()
Используется для указания, что должен быть предоставлен подходящий контекст. Обычно применяется в разработке и при рефакторинге.

🟠context.WithCancel(parent Context) (ctx Context, cancel CancelFunc)
Создает новый контекст с возможностью отмены.

🟠context.WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)
Создает контекст, который автоматически отменяется в указанный deadline.

🟠context.WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
Аналогичен WithDeadline, но устанавливает время жизни контекста на основе заданного таймаута.

func operation1(ctx context.Context) {
    select {
    case <-time.After(5 * time.Second):
        fmt.Println("operation1 completed")
    case <-ctx.Done():
        fmt.Println("operation1 cancelled")
    }
}

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

    go operation1(ctx)

    // Дожидаемся завершения или отмены операции
    <-ctx.Done()
    if err := ctx.Err(); err != nil {
        fmt.Println("main:", err)
    }
}

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

🤔 Что делать, если канал интовый и был получен ноль?

Проверить второй параметр при чтении:
- Если ok == false – канал закрыт, а 0 не является значением.
- Если ok == true – это действительное значение 0, переданное в канал.

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

🤔 Какие преимущества есть у Go?

Go (или Golang) обладает рядом преимуществ, которые делают его популярным.

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

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

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

package main

import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 3; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("world")
    say("hello")
}

🟠Сильная система типов и безопасность памяти
Имеет строгую систему типов, которая помогает предотвращать ошибки на этапе компиляции. В языке отсутствуют неявные преобразования типов, что снижает вероятность ошибок. Также Go управляет памятью с помощью встроенного сборщика мусора (garbage collector), что предотвращает утечки памяти.

🟠Встроенная поддержка
Стандартных инструментов
Поставляется с богатым набором встроенных инструментов для разработки, таких как:
go fmt для автоматического форматирования кода.
go test для запуска тестов.
go build и go run для сборки и выполнения программ.
go doc для генерации документации.

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

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

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

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

🤔 Через какой канал возможна проверка работы горутины?

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

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

🤔 Чем stream отличается от unary?

В контексте gRPC (Google Remote Procedure Call) unary и stream — это два разных типа взаимодействия между клиентом и сервером.

🚩Unary RPC (Обычный вызов)

🟠Unary (унарный) вызов
это стандартный запрос-ответ:
Клиент отправляет одно сообщение → сервер отвечает одним сообщением.

service UserService {
    rpc GetUserInfo(UserRequest) returns (UserResponse);
}

Go-реализация Unary RPC

func (s *server) GetUserInfo(ctx context.Context, req *pb.UserRequest) (*pb.UserResponse, error) {
    user := &pb.UserResponse{
        Id:    req.Id,
        Name:  "John Doe",
        Email: "john@example.com",
    }
    return user, nil // Обычный ответ
}

🚩Streaming RPC (Потоковый вызов)

В streaming RPC передача данных идёт потоком. gRPC поддерживает три вида стримов:

🟠Server Streaming (Поток от сервера)
Клиент отправляет один запрос → сервер возвращает поток ответов.

service UserService {
    rpc GetUserActivity(UserRequest) returns (stream ActivityResponse);
}

Go-реализация Server Streaming

func (s *server) GetUserActivity(req *pb.UserRequest, stream pb.UserService_GetUserActivityServer) error {
    activities := []string{"Login", "Upload File", "Logout"}
    for _, activity := range activities {
        err := stream.Send(&pb.ActivityResponse{Message: activity})
        if err != nil {
            return err
        }
        time.Sleep(time.Second) // Имитация задержки
    }
    return nil
}

🟠Client Streaming (Поток от клиента)
Клиент отправляет поток данных → сервер отвечает одним ответом.

service UploadService {
    rpc UploadFile(stream FileChunk) returns (UploadResponse);
}

Go-реализация Client Streaming

func (s *server) UploadFile(stream pb.UploadService_UploadFileServer) error {
    var totalSize int64
    for {
        chunk, err := stream.Recv()
        if err == io.EOF {
            return stream.SendAndClose(&pb.UploadResponse{Size: totalSize})
        }
        if err != nil {
            return err
        }
        totalSize += chunk.Size
    }
}

🟠Bidirectional Streaming (Двунаправленный поток)
Клиент и сервер обмениваются данными в потоке одновременно.

service ChatService {
    rpc Chat(stream ChatMessage) returns (stream ChatMessage);
}

Go-реализация Bi-directional Streaming

func (s *server) Chat(stream pb.ChatService_ChatServer) error {
    for {
        msg, err := stream.Recv()
        if err == io.EOF {
            return nil
        }
        if err != nil {
            return err
        }
        response := &pb.ChatMessage{Text: "Echo: " + msg.Text}
        if err := stream.Send(response); err != nil {
            return err
        }
    }
}

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

🤔 Как закрыть канал?

Использовать close(channel). После этого:
- Новые записи приведут к panic.
- Чтение продолжится, пока не будет пустым.
- Чтение из пустого закрытого канала даст zero-value.

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

🤔 Что такое интеграционные тесты?

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

🚩Зачем они нужны?

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

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

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

🚩Как их писать?

Интеграционные тесты могут требовать наличия нескольких зависимостей, таких как база данных, внешние API или другие сервисы. Настройте тестовую среду, которая будет эмулировать реальную среду.

      // main.go
   package main

   import (
       "database/sql"
       _ "github.com/mattn/go-sqlite3"
       "log"
   )

   type User struct {
       ID   int
       Name string
   }

   func CreateUser(db *sql.DB, name string) (int, error) {
       res, err := db.Exec("INSERT INTO users(name) VALUES(?)", name)
       if err != nil {
           return 0, err
       }
       id, err := res.LastInsertId()
       if err != nil {
           return 0, err
       }
       return int(id), nil
   }

   func GetUser(db *sql.DB, id int) (User, error) {
       var user User
       err := db.QueryRow("SELECT id, name FROM users WHERE id = ?", id).Scan(&user.ID, &user.Name)
       if err != nil {
           return user, err
       }
       return user, nil
   }

   func main() {
       db, err := sql.Open("sqlite3", ":memory:")
       if err != nil {
           log.Fatal(err)
       }
       defer db.Close()

       _, err = db.Exec("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
       if err != nil {
           log.Fatal(err)
       }
   }
        // main_test.go
   package main

   import (
       "database/sql"
       "testing"
       _ "github.com/mattn/go-sqlite3"
   )

   func setupTestDB(t *testing.T) *sql.DB {
       db, err := sql.Open("sqlite3", ":memory:")
       if err != nil {
           t.Fatal(err)
       }
       _, err = db.Exec("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
       if err != nil {
           t.Fatal(err)
       }
       return db
   }

   func TestCreateAndGetUser(t *testing.T) {
       db := setupTestDB(t)
       defer db.Close()

       // Создание пользователя
       userID, err := CreateUser(db, "John Doe")
       if err != nil {
           t.Fatalf("Failed to create user: %v", err)
       }

       // Получение пользователя
       user, err := GetUser(db, userID)
       if err != nil {
           t.Fatalf("Failed to get user: %v", err)
       }

       // Проверка результатов
       if user.Name != "John Doe" {
           t.Errorf("Expected name to be 'John Doe', got %s", user.Name)
       }
   }

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

🤔 Какие действия можно производить с каналами?

1. Отправлять данные (chan <- value).
2. Читать данные (value := <-chan).
3. Закрывать (close(chan)).
4. Использовать в select для обработки множественных каналов.
5. Создавать буферизированные и небуферизированные каналы.
6. Использовать range для чтения оставшихся данных из закрытого канала.

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

На easyoffer 2.0 появится:
🎯 Тренажер "Проработка вопросов"

✅ Метод интервальных повторений и флеш-карточки
✅ Персональный подход изучения на основе ваших ответов
✅ Упор на самые частые вопросы

📌 Интервальные повторения по карточкам это научно доказанный метод эффективного обучения. Каждая карточка – это вопрос, который задают на собеседовании, вы можете выбрать "Не знаю", "Знаю", "Не спрашивать". После ответа вам показывается правильный ответ и возможность изучить вопрос подробнее (примеры ответов других людей). От ваших ответов зависит то, как часто карточки будут показываться на следующей тренировке. Трудные вопросы показываются чаще, простые – реже. Это позволяет бить в слабые места. Кроме того, изначальный порядок карточек зависит от частотности (вероятности встретить вопрос).

🚀 Благодаря этому тренажеру вы сможете очень быстро подготовиться к собеседованию, т.к. фокусируетесь отвечать на самые частые вопросы. Именно так готовился я сам, когда искал первую работу программистом.

Уже в течение недели я объявлю о старте краудфандинговой кампании на сбор финансирования, чтобы ускорить разработку сайта. Все кто поддержит проект до официального релиза получат самые выгодные условия пользования сервисом. А именно 1 год доступа к сайту по цене месячной подписки.

‼️ Очень важно, чтобы как можно больше людей поддержали проект в первые дни, по-этому те кто окажет поддержку первыми получат еще более выгодную стоимость на годовую подписку и существенный 💎 бонус о котором я позже расскажу в этом телеграм канале. Подписывайтесь, чтобы узнать о старте проекта раньше других и воспользоваться лимитированными вознаграждениями.

🤔 Что такое массив (array)?

Массив (array) — это структура данных, которая представляет собой фиксированную последовательность элементов одного типа. Все элементы массива размещены в памяти последовательно и имеют одинаковый тип. Используются для хранения коллекций данных, где количество элементов заранее известно и фиксировано.

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

🟠Фиксированный размер
Размер массива задается при его объявлении и не может изменяться во время выполнения программы.
🟠Тип элементов
Все элементы массива имеют один и тот же тип.
🟠Непрерывное размещение в памяти
Элементы массива хранятся последовательно в памяти, что обеспечивает быстрый доступ к любому элементу по индексу.

🚩Объявление и инициализация массивов

Массивы объявляются с указанием типа элементов и фиксированного размера:

var arr [5]int

🟠Инициализация массива
Могут быть инициализированы при объявлении:

arr := [5]int{1, 2, 3, 4, 5}

Можно также инициализировать массив частично, оставив остальные элементы равными нулям:

arr := [5]int{1, 2}

🟠Доступ к элементам массива
Осуществляется с использованием индексов, начиная с 0:

fmt.Println(arr[0]) // 1
arr[1] = 10
fmt.Println(arr[1]) // 10

🟠Длина массива
Фиксирована и задается при его объявлении. Ее можно получить с помощью функции len:

fmt.Println(len(arr)) // 5

🟠Копирование массива
При присваивании одного массива другому копируются все элементы:

arr1 := [5]int{1, 2, 3, 4, 5}
arr2 := arr1
arr2[0] = 10
fmt.Println(arr1) // [1 2 3 4 5]
fmt.Println(arr2) // [10 2 3 4 5]

🟠Передача массива в функции
Копируется весь массив:

func modifyArray(a [5]int) {
    a[0] = 10
}

arr := [5]int{1, 2, 3, 4, 5}
modifyArray(arr)
fmt.Println(arr) // [1 2 3 4 5]

🟠Сравнение массивов
С помощью оператора ==, если они имеют одинаковую длину и тип элементов:

arr1 := [3]int{1, 2, 3}
arr2 := [3]int{1, 2, 3}
arr3 := [3]int{4, 5, 6}

fmt.Println(arr1 == arr2) // true
fmt.Println(arr1 == arr3) // false

Пример

package main

import (
    "fmt"
)

func main() {
    // Объявление и инициализация массива
    arr := [5]int{1, 2, 3, 4, 5}

    // Доступ к элементам
    fmt.Println("First element:", arr[0]) // First element: 1

    // Изменение элементов
    arr[1] = 10
    fmt.Println("Modified array:", arr) // Modified array: [1 10 3 4 5]

    // Длина массива
    fmt.Println("Length of array:", len(arr)) // Length of array: 5

    // Копирование массива
    arr2 := arr
    arr2[0] = 20
    fmt.Println("Original array:", arr) // Original array: [1 10 3 4 5]
    fmt.Println("Copied array:", arr2)  // Copied array: [20 10 3 4 5]

    // Передача массива в функцию
    modifyArray(arr)
    fmt.Println("Array after modifyArray call:", arr) // Array after modifyArray call: [1 10 3 4 5]
}

func modifyArray(a [5]int) {
    a[0] = 10
}

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

🤔 Как использовать индексы в JOIN запросах MySQL?

Индексы в JOIN помогают ускорить соединение таблиц, уменьшая количество сравниваемых строк. Для эффективного JOIN следует:
- Использовать индексы на полях соединения (ON table1.id = table2.foreign_key).
- Убедиться, что индексы покрывают условия фильтрации (WHERE).
- Проверить использование индексов с EXPLAIN.
- Предпочитать INNER JOIN, так как он быстрее LEFT JOIN при одинаковых условиях.

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

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

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

🚩Причины

🟠Определение требований
Написание тестов перед кодом помогает разработчикам четко определить требования к функции или модулю. Тесты выступают в роли спецификации, описывающей, как должен работать код. Это помогает избежать недоразумений и гарантирует, что все требования учтены с самого начала.

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

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

🟠Обратная связь и уверенность
Тесты, написанные перед кодом, обеспечивают немедленную обратную связь. Если код не проходит тест, это означает, что он не соответствует требованиям. Это позволяет разработчикам быстро обнаруживать и исправлять ошибки, повышая уверенность в корректности кода.

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

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

🚩Пример процесса TDD

1⃣Написание теста

package main

import "testing"

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Expected 5, but got %d", result)
    }
}

2⃣Запуск теста
На этом этапе тест не пройдет, так как функция Add еще не реализована.

3⃣Реализация кода

package main

func Add(a, b int) int {
    return a + b
}

4⃣Запуск теста снова
Теперь тест пройдет, так как функция Add реализована корректно.

5⃣Рефакторинг
При необходимости выполняется рефакторинг кода для улучшения его структуры, при этом тесты продолжают проходить, что гарантирует сохранение функциональности.

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

🤔 Что такое частичные индексы?

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

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

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

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

🚩Когда использование небезопасно

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    buffer := make([]byte, 10)

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            buffer[i] = byte(i) // Несколько горутин одновременно модифицируют буфер
        }(i)
    }

    wg.Wait()
    fmt.Println("Buffer:", buffer)
}

🚩Безопасное использование одного буфера

🟠Только чтение
Если несколько горутин только читают из буфера, это безопасно. Пример безопасного использования:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    buffer := []byte("Hello, World!")

    for i := 0; i < len(buffer); i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            fmt.Printf("buffer[%d]: %c\n", i, buffer[i])
        }(i)
    }

    wg.Wait()
}

🟠Использование мьютексов
Для синхронизации доступа к буферу используйте мьютексы (sync.Mutex). Это гарантирует, что только одна горутина в данный момент модифицирует буфер.

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    var mu sync.Mutex
    buffer := make([]byte, 10)

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            mu.Lock()
            buffer[i] = byte(i)
            mu.Unlock()
        }(i)
    }

    wg.Wait()
    fmt.Println("Buffer:", buffer)
}

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

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    buffer := []byte("Hello, World!")

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            localBuffer := make([]byte, len(buffer))
            copy(localBuffer, buffer)
            localBuffer[i] = byte(i)
            fmt.Printf("Goroutine %d: %s\n", i, localBuffer)
        }(i)
    }

    wg.Wait()
}

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

🤔 Для чего используется частичный индекс?

Частичные индексы позволяют:
- Экономить место – индекс создается только для нужных значений.
- Ускорять запросы – за счет меньшего размера индекс быстрее сканируется.
- Фильтровать данные – индекс применяется только к записям, которые соответствуют определенному условию.

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

На easyoffer 2.0 появится новый раздел:
Задачи с собеседований

🟠Задачи на Алгоритмические, Live-coding и System Design из реальных собеседований
🟠Вероятность встретить ту или иную задачу
🟠Возможность подготовиться к задачам конкретной компании

Есть много сайтов, на которых можно тренироваться решать задачи, но у них у всех одна проблема – сами задачи люди просто выдумывают. На easyoffer 2.0 вы сможете готовиться к live-coding и system design секциям на основе задач из реальных собеседований. Вы можете найдете самые частые задачи и сделаете упор на их решение.

Считаные дни остались до старта краудфандинговой кампании, чтобы ускорить разработку easyoffer 2.0. Все кто, поддержал проект на этом этапе смогу получить 1 год доступа к сайту по цене месячной подписки, а те кто поддержат проект раньше других ито дешевле + получат существенный бонус. Следите за стартом 👉 в этом телеграм канале.