Какие основные принципы и концепции программирования важны для Go-разработчика?

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

1. Инкапсуляция, или "Спрячь своё говно" Суть: Не выставляй напоказ все свои кишки. Показывай миру только то, с чем можно нормально взаимодействовать. В Go: Всё просто, как три копейки. Если имя (типа, функции, переменной) начинается с БОЛЬШОЙ буквы — это как крик "Эй, мир, бери меня, я твой!". Оно экспортируется из пакета. Со строчной — это твоё личное, домашнее, в пределах пакета. Никаких private, public — одна буква решает. Гениально и немного по-хулигански.

2. Композиция вместо наследования, или "Забудь про папу-объект" Суть: В Go нихуя нет классического наследования, "я — сын своего отца, унаследовал его нос и долги". Тут подход "я взял этого чувака и просто встроил его в себя". Это называется встраивание (embedding). В Go: Смотри, как это выглядит. Представь, у тебя есть мотор.

type Engine struct { Power int }
func (e *Engine) Start() { fmt.Println("Дзынь! Завелся!") }

А теперь ты делаешь машину. Ты не говоришь "моя машина — это мотор". Ты говоришь "в моей машине ЕСТЬ мотор, и я могу пользоваться его кнопками".

type Car struct {
    Engine // Просто встраиваешь. Во, сука, вот так.
    Wheels int
}
// c := Car{}
// c.Start() // И ты можешь сразу стартануть мотор! Он как будто твой собственный метод!

Вот и вся магия. Никакой ебаной иерархии в тридцать этажей.

3. Полиморфизм через интерфейсы, или "Если оно крякает как утка..." Суть: Тебе нужно, чтобы и собака, и кошка, и попугай могли издавать звук. Тебе похуй, кто они. Тебе важно, чтобы у них был метод Speak(). В Go: Объявляешь интерфейс — список методов, которые тебе нужны.

type Speaker interface {
    Speak() string
}

А теперь делаешь хоть табуретку. Если у табуретки есть метод Speak() string, который возвращает "Ай, бля, сел!", то Go говорит: "О, табуретка удовлетворяет интерфейсу Speaker!". Это и есть утиная типизация — если штука ходит как утка и крякает как утка, то для нас она и есть утка, ёпта.

func MakeSound(s Speaker) {
    fmt.Println(s.Speak()) // Мне плевать, кто ты. Говори!
}

4. Конкурентность, или "Давайте все сразу, но без драк" Суть: Это про то, чтобы делать много дел одновременно. Не путай с параллельностью (это когда на разных ядрах). Go даёт тебе два главных инструмента, чтобы не устроить адскую мясорубку из данных. В Go:

• Горутины — это охрененно легковесные потоки. Запускаются словом go. Их можно запустить овердохуища, и ОС даже не вспотеет.
• Каналы — это такие типизированные трубы. Одна горутина пихнула в канал данные, другая — взяла. Всё безопасно, без гонок (race conditions), если, конечно, ты не мудак и не делаешь глупостей.

  ch := make(chan string) // Создал канал для строк
  go func() { // Запустил горутину (вот эта 'go'!)
  ch <- "Привет из другой горутины, чувак!" // Пихнул в канал
  }()
  msg := <-ch // Достал из канала. Программа тут подождёт, если сообщения ещё нет.
  fmt.Println(msg)

  Без каналов — это анархия, бардак и паника в рантайме. Каналы — это закон.

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

• SOLID: Это не про твёрдое состояние. Это пять правил для взрослых дяденек.
  • S — Одна штука должна делать одно дело. Не пихай в одну функцию и отправку email, и расчёт зарплаты, и запись в лог. Это пиздец как не по S.
  • O — Код должен быть открыт для расширения, но закрыт для изменений. Хочешь новую фичу — не перелопачивай старый, проверенный код, а расширь его через новые типы и интерфейсы.
  • L — Если программа работала с Птицей, то она должна работать и с Уткой, которая является птицей. Нарушишь — получишь сюрприз.
  • I — Не делай жирные, всеобъемлющие интерфейсы. Дроби их на мелкие и специфичные. Лучше десять маленьких, чем один большой, который всех ебёт.
  • D — Зависи от абстракций (интерфейсов), а не от конкретных реализаций (структур). Это даёт гибкость.
• DRY (Don't Repeat Yourself): Не повторяйся, блядь. Скопировал код второй раз — уже чувствуй себя говнокодером. Выноси в функцию, в метод, в отдельный пакет.
• KISS (Keep It Simple, Stupid): Главный принцип. Делай проще, тупица! Если решение выглядит как ебаный паровоз из костылей и велосипедов, ты идёшь не туда. В Go это особенно актуально — язык сам по себе простой.

Вот, собственно, и всё. Держи эти штуки в голове, когда пишешь, и есть шанс, что твой код не захотят закопать вместе с тобой. Удачи, ёпта!