🤍Добро пожаловать в Go Level Up — твой старт в Go-Backend!🥳

💡 Учимся: Осваиваем Go с нуля, разбираем синтаксис, паттерны и лучшие практики.

⚡️ Практикуем: Пишем код вместе, разбираем ошибки, обсуждаем их.

🤖 Моки & Сервисы: Создаем тестовые API, микросервисы и полезные инструменты в командах.

🎯 Развиваемся: Помогаем друг другу расти как backend-команде.

🤔Что здесь будет?

✅ Пошаговые гайды и туториалы
✅ Разбор реальных кейсов и задач
✅ Совместные проекты и код-ревью
✅ Поддержка комьюнити и ответы на вопросы

📌 Правила просты:

Максимум практики, минимум воды
Делимся знаниями и опытом
Готов прокачаться в Go🧐Поехали! 🚀

Приветствую всех любителей Go! 🥳

📌Меня зовут Рома, и я разработчик на Go уже больше 5 лет. За это время я не только успел поработать над множеством интересных проектов, но и приобрел ценный опыт, которым хочу поделиться с вами в роли ментора🖱

Почему Go – отличный выбор, и почему вам стоит ко мне присоединиться➡️

➡️Простота и эффективность: Go славится своим чистым и лаконичным синтаксисом, благодаря чему его легко изучать и поддерживать. Этот язык идеально подходит для создания высокопроизводительных и масштабируемых приложений.
➡️Современность: Go был разработан Google с учетом потребностей современной разработки. Он отлично справляется с параллельным программированием, что делает его идеальным для создания распределенных систем.
➡️Востребованность: Go – один из самых востребованных языков на рынке труда. Компании активно ищут Go-разработчиков для работы над облачными сервисами, микросервисной архитектурой и другими передовыми технологиями.
➡️Огромное сообщество: Сообщество Go – одно из самых дружелюбных и активных в мире программирования. Вы всегда найдете помощь, поддержку и вдохновение.

💬Что я предлагаю как ментор:

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

🟢Особенности работы со мной:

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

Если вы хотите начать свой путь в мир Go или улучшить свои навыки, я буду рад стать вашим проводником!💻

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

#go #golang #программирование #менторство #разработка #обучение #google #разработчик

➡️Код выведет: 10 2 3 5

➡️Идем по строчкам:
Создается слайс len=0 и cap=5, далее в него записываем 1, 2, 3. Массив родитель не аллоцировался, так как до cap мы еще не дошли.

📌Функция?! в рамках нее мы принимаем слайс, добавляем 4 и меняем первый элемент. И тут же мы ее вызываем, передавая s. И тут возникает вопрос: s вроде бы ссылочный тип данных, получается передав его в функцию, мы меняем ❕именно его непосредственно по ссылке, ведь так?)

❌А вот и нет, в го ВСЕ аргументы функции передаются по значению, то есть копируются. Получается внутри функции
sl - копия s ❕ То есть структура состоящая из трех полей len, cap, arr (ссылка на массив родитель) скопировалась

💻Теперь самый сок.
Мы добавили в sl 4 и поменяли первый элемент(помним в голове, что sl ссылается на тот же массив родитель), и получается, что у sl len=4, cap=5. Массив родитель в памяти выглядит так: [10 2 3 4]

Довольные выходим из функции, и приходим к s, у которого len=3, cap=5 (мы же с ним ничего не делали). И получается, что массив родитель [10 2 3 4], но len у него 3, то есть по сути сам s выглядит как [10 2 3]. И как раз-таки при append мы добавляем 5 в ячейку где уже была 4, и перезаписываем ее 🔘(память одна и та же). Таким образом итог вывода в s [10 2 3 5]🤍

🦆👎Утиная типизация (Duck Typing)

💡Идея: Если что-то ходит как утка и крякает как утка, то это утка.

💬Очень полезная вещь в продуктовой разработке, регулярно пользуюсь, когда хочу изолировать реализацию сущности (ее поля, от чего зависит и тд) от других сущностей. 💎Особенно полезно, когда пилим сервис и у нас есть слои, так вот по принципам красивой разработки и soLiD🟢 (в данном случае такой подход позволяет придерживаться сразу двух принципов L, D) архитектурные слои должны быть изолированными и независимыми друг от друга, таким образом любой слой очень просто меняется, не затрагивая другие.

Благодаря этому написание моков и подмена слоев на любую другую реализацию (например, юзали библиотеку БД gorm, а в v2-версии слоя решили перейти на самописные SQL запросы) превращается из боли и страданий, в кайф и красоту. На моем опыте я раз 20 переписывал слои сервиса, чтобы их просто замокать и сделать тесты, потому что все завязывались на реализации сущностей😭

type Speaker interface {
  Speak() string
}

type Duck struct {
  Name string
}

func (d Duck) Speak() string {
  return fmt.Sprintf("%s говорит Кря", d.Name)
}

type Pigeon struct {
  Name string
}

func (c Pigeon) Speak() string {
  return fmt.Sprintf("%s говорит Гули-Гули", c.Name)
}

func main() {
  animals := []Speaker{
    Duck{Name: "Утка"},
    Pigeon{Name: "Голубь"},
  }

  for _, a := range animals {
    a.Speak()
  }
}

➡️Код выведет: [] [Test]⬅️

Лучшее объяснение этого вывода состоит в идее copy. Предназначена эта функция для копирования элементов слайса-родителя в слайс-ребенок, отвязывая от ссылки на массив родитель 🧐(частая ошибка начинающих), однако делает она это достаточно топорно, она не может ни проинициализировать слайс-ребенок, ни изменить его как-либо, чтобы все элементы родителя скопировались.📌

🖱Всё, что умеет эта функция - глупое перекладывание элементов по ячейкам.

То есть, если есть выделенная под элемент ячейка слайса, то copy сделает свою работу, а вот если ячейки не оказалось, то copy просто пожимает плечами. ➡️

Теперь важный момент на понимание слайса: выделенные ячейки - это не cap! Это len! Ровно по этому числу мы понимаем сколько проинициализированных ячеек в слайсе

💬Теперь к результатам:

В sl мы ничего не получили по причине того, что инициализация вида

var sl []string

это инициализация nil-слайса, у которого нет ни длины, ни капасити 🔜copy не смог ничего перетащить

💡Во втором примере у sl1 уже установлена длина 1 и капасити 3, следовательно copy переносит в инициализированную ячейку элемент

❕Польза copy:
На просторах коммерческой разработки мало встречал использования этой функции, хотя и не понимаю почему😢 Встречал много решений, где люди копировали слайс через форики, чтобы потом его мутировать/менять и не завязываться двумя слайсами на один массив родитель (❌опасно!). На мой взгляд, решение громоздкое и некрасивое. copy гораздо эффективнее и лаконичнее, и к тому же оно может также использоваться как получение так называемого ломтика.⬅️

func main() {
  sl := []int{1, 2, 3, 4}

  part := sl[:2]

  partByCopy := make([]int, 2)
  copy(partByCopy, sl)

  // Изменим sl, чтобы показать наследование ссылки на массив-родитель
  sl[0] = 5

  fmt.Println(part, partByCopy)
  // Получаем вывод:[5 2] [1 2] -> получение базового ломтика, приводит к риску мутаций, в отличие от copy
}

➡️Итак, фаталы и конкурентные ошибки мапы это классика начинающего Go-разраба💻

🖱Но что делать, когда так хочется заюзать мапу конкурентно, чтобы не блокироваться на вставку/чтение, и при этом не упасть с злосчастным fatal error. 😨

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

📌В данном примере лучше юзать не просто мьютекс, а RWMutex. Разница? Read-Write Mutex позволяет блокировать блок памяти только на запись, и при этом разрешать этот же блок читать.👣

type SafeMap struct {
  sync.RWMutex
  data map[string]int
}

func main() {
  protectedMap := SafeMap{
    data: map[string]int{"a": 1},
  }

  go protectedMap.Read()
  time.Sleep(1 * time.Second)
  go protectedMap.Write()
  time.Sleep(1 * time.Minute)
}

func (sm *SafeMap) Read() {
  for {
    sm.RLock()
    fmt.Println(sm.data["a"])
    sm.RUnlock()
  }
}

func (sm *SafeMap) Write() {
  for i := 0; ; i++ {
    sm.Lock()
    sm.data[fmt.Sprintf("%d", i)] = i
    sm.Unlock()
  }
}

Коллеги, спасибо за участие в опросе! Большинство выбрало вариант 17:00. 💻

🖱Сегодня в 17:00 (МСК) созвон — обсудим как писать микросервис на го. Жду всех!📌