🤔 Что такое Dark (скрытые) или А/В-развертывания?

Это скрытое развертывание новой версии приложения без вовлечения реальных пользователей, например, для проверки ее совместимости или производительности. A/B deployment – это развертывание двух разных версий приложения для анализа их эффективности, например, на основе метрик пользовательского поведения.

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

🤔 Как называется механизм сборки мусора?

В Go механизм сборки мусора называется Garbage Collector (GC).

🚩Как работает сборщик мусора в Go?

Go использует автоматический сборщик мусора с конкурентной, трицветной, инкрементальной стратегией.

🟠Конкурентный (Concurrent)
выполняется параллельно с работой программы.
🟠Трёхцветный (Tri-color)
объекты помечаются как белые, серые и чёрные.
🟠Инкрементальный (Incremental)
работает порциями, а не останавливает программу надолго.

🚩Алгоритм трёхцветной маркировки

🟠Белые объекты
мусор, который будет удалён.
🟠Серые объекты
те, которые находятся в обработке.
🟠Чёрные объекты
используемые объекты, которые не подлежат удалению.

🚩Оптимизация GC в Go

Чтобы уменьшить нагрузку на GC:
Используйте пул объектов (sync.Pool).
Минимизируйте аллокации в куче (например, используйте []byte вместо string, если можно).
Ограничивайте долгоживущие объекты, так как они реже сканируются.

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

🤔 Что такое SLA?

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

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

🤔 Как эффективно склеивать множество строк?

В Go эффективное объединение строк – важная задача, поскольку строки неизменяемые. Неправильный подход (например, простая конкатенация s1 + s2 + s3) может привести к множественным аллокациям памяти и копированиям.

🚩Способы объединения строк

Использование strings.Builder (Рекомендуется)
Это самый эффективный способ склеивания строк, так как он минимизирует количество аллокаций.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var sb strings.Builder

    sb.WriteString("Hello")
    sb.WriteString(", ")
    sb.WriteString("World!")

    result := sb.String()
    fmt.Println(result) // Hello, World!
}

Использование + (Неэффективно )

s := "Hello" + ", " + "World!"

Использование fmt.Sprintf (Неэффективно )

s := fmt.Sprintf("%s, %s!", "Hello", "World")

Использование strings.Join (Хорошо для срезов )
Если строки хранятся в []string, strings.Join – это оптимальный вариант

package main

import (
    "fmt"
    "strings"
)

func main() {
    words := []string{"Hello", "World", "Go"}
    result := strings.Join(words, ", ")
    fmt.Println(result) // Hello, World, Go
}

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

🤔 Что такое SLO?

Это конкретная цель SLA, например, доступность сервиса 99.9% времени в месяц. SLO задает количественные метрики, которых должен придерживаться сервис.

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

🤔 Чем горутины отличаются от тредов?

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

🚩Модель управления

Горутины — это легковесные "зеленые" потоки, управляемые Go runtime. Они не являются потоками операционной системы, и Go runtime отвечает за их планирование и выполнение на доступных физических потоках. Это позволяет создавать тысячи и даже миллионы горутин в рамках одного приложения с относительно небольшими затратами памяти и CPU.
Треды — это потоки выполнения, управляемые непосредственно операционной системой. Каждый тред занимает значительно больше ресурсов, чем горутина, особенно в плане памяти и времени на создание и управление. Треды более подходят для задач, требующих высокой вычислительной мощности и прямого взаимодействия с операционной системой.

🚩Затраты ресурсов

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

🚩Масштабируемость

Горутины могут масштабироваться до большого количества параллельных задач благодаря меньшим требованиям к ресурсам и управлению со стороны runtime Go.
Треды ограничены в масштабируемости физическими ресурсами системы и более высокими затратами на управление.

🚩Контекст переключения

Горутины имеют намного более эффективный контекст переключения, так как Go runtime оптимизирован для работы с большим количеством горутин и их переключением.
Треды терпят большие затраты времени на переключение контекста, так как операционной системе требуется больше времени для управления потоками.

package main

import (
    "fmt"
    "time"
)

func say(text string) {
    for i := 0; i < 5; i++ {
        fmt.Println(text)
        time.Sleep(time.Millisecond * 500)
    }
}

func main() {
    go say("Hello")
    say("World")
}

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

🤔 Что такое SLI?

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

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

🤔 Почему пустой интерфейс можно привести к любому типу?

В Go пустой интерфейс interface{} является особым типом, который может содержать значение любого типа. Это связано с тем, что в Go любой тип реализует пустой интерфейс, поскольку в нем нет методов, которые нужно реализовать.

🚩Пустой интерфейс

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

type interface{} interface {}

🚩Внутреннее представление интерфейсов в Go

🟠Type
Типа конкретного значения
🟠Value
Самого значения

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

🚩Приведение пустого интерфейса к конкретному типу

Когда значение из пустого интерфейса приводится к конкретному типу, происходит проверка типа во время выполнения. Если значение внутри интерфейса действительно является указанным типом, приведение успешно. В противном случае приведение не удается, и возвращается значение nil или происходит паника, если приведение выполнено без проверки.

Присваивание значений пустому интерфейсу

package main

import "fmt"

func main() {
    var i interface{}
    i = 42
    fmt.Println(i) // 42

    i = "hello"
    fmt.Println(i) // hello
}

Утверждение типа (Type Assertion)

package main

import "fmt"

func main() {
    var i interface{} = "hello"

    // Утверждение типа с проверкой
    s, ok := i.(string)
    if ok {
        fmt.Println("String:", s)
    } else {
        fmt.Println("Not a string")
    }

    // Утверждение типа без проверки
    // Это вызовет панику, если тип не соответствует
    s = i.(string)
    fmt.Println("String:", s)
}

Использование switch для проверки типа

package main

import "fmt"

func printType(i interface{}) {
    switch v := i.(type) {
    case string:
        fmt.Println("String:", v)
    case int:
        fmt.Println("Integer:", v)
    case bool:
        fmt.Println("Boolean:", v)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

func main() {
    printType("hello")
    printType(42)
    printType(true)
    printType(3.14)
}

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

🤔 Какие инструменты CI/CD известны?

К популярным инструментам CI/CD относятся Jenkins, GitLab CI/CD, GitHub Actions, CircleCI, Travis CI и Azure DevOps. Эти инструменты помогают автоматизировать сборку, тестирование, развертывание и мониторинг приложений.

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

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

В Go строки представлены как набор байтов ([]byte), но количество символов может отличаться, так как некоторые символы занимают несколько байтов (например, Unicode).

🚩Способы подсчёта символов в строке

len(s) – количество байтов (НЕ символов!)

s := "Привет"
fmt.Println(len(s)) // 12, потому что кириллические символы занимают 2 байта

utf8.RuneCountInString(s) – количество символов (РЕКОМЕНДУЕТСЯ )

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "Привет"
    fmt.Println(utf8.RuneCountInString(s)) // 6, правильно считает символы
}

Подсчёт через range (альтернативный метод)

count := 0
for range "Привет" {
    count++
}
fmt.Println(count) // 6

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

🤔 Как обеспечить непрерывность и стабильность деплоя приложения?

Для обеспечения стабильности используются методы развертывания (например, blue-green или canary deployment), интеграция тестирования в CI/CD pipeline и инструменты мониторинга. Также важны автоматические откаты на предыдущую версию в случае ошибок.

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

🤔 В чем разница между императивным и декларативным?

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

🚩Императивное программирование

Это стиль программирования, где выражается последовательность команд для выполнения задач. В этом подходе программист указывает машине, как изменять своё состояние пошагово, контролируя поток выполнения через управляющие конструкции, такие как циклы, условные операторы и т.д.
🟠Подробное описание процесса
Программист должен указывать все шаги, которые необходимо выполнить для достижения результата.
🟠Примеры языков
Java, C, Python в их традиционном использовании.
🟠Управление состоянием
Императивные программы часто включают явное управление состоянием и его изменениями.

# Императивный подход к сортировке массива методом пузырька
def bubble_sort(array):
    n = len(array)
    for i in range(n):
        for j in range(0, n-i-1):
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]
    return array

🚩Декларативное программирование

Это стиль программирования, где описывается желаемый результат, но не детализируется процесс его достижения. В декларативном стиле программа определяет, что должно быть сделано, а не как.
🟠Абстракция от процесса
Описываются желаемые свойства результата, а система сама определяет, как его достичь.
🟠Примеры языков
SQL, HTML, CSS, функциональные языки программирования, такие как Haskell.
🟠Сокрытие сложности
Декларативный подход часто предполагает высокий уровень абстракции, что уменьшает количество деталей, которые нужно учитывать.

-- Декларативный запрос в SQL для получения списка сотрудников, отсортированного по зарплате
SELECT name, salary FROM employees ORDER BY salary DESC;

🚩Основные различия

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

🟠Управление состоянием
Императивный подход требует активного управления состоянием программы, в то время как в декларативном подходе состояние управляется системой или вовсе абстрагировано.

🟠Поддержка языка
Разные языки поддерживают разные стили программирования. Некоторые языки, как JavaScript, могут поддерживать оба стиля в зависимости от использования.

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

🤔 С какими проблемами при деплое продукта сталкивался, как митигировал?

Часто встречаются проблемы с некорректными конфигурациями, зависимостями или ошибками в коде. Для их решения используют автоматизацию через CI/CD, предварительное тестирование, настройку мониторинга и механизм откатов. Например, в случае ошибки новая версия может быть заменена предыдущей без длительного простоя.

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

🤔 Как наследование осуществлено в Golang?


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

🚩Композиция

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

package main

import "fmt"

// Определение структуры
type Engine struct {
    Power int
}

func (e Engine) Start() {
    fmt.Println("Engine started with power:", e.Power)
}

// Определение другой структуры, которая включает первую
type Car struct {
    Brand string
    Engine
}

func main() {
    myCar := Car{
        Brand: "Toyota",
        Engine: Engine{Power: 150},
    }

    fmt.Println("Car brand:", myCar.Brand)
    myCar.Start() // Вызов метода встроенной структуры
}

🚩Интерфейсы

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

package main

import "fmt"

// Определение интерфейса
type Drivable interface {
    Drive()
}

// Определение структуры, реализующей интерфейс
type Car struct {
    Brand string
}

func (c Car) Drive() {
    fmt.Println(c.Brand, "is driving")
}

// Еще одна структура, реализующая интерфейс
type Bike struct {
    Brand string
}

func (b Bike) Drive() {
    fmt.Println(b.Brand, "is driving")
}

// Функция, принимающая интерфейс
func StartDriving(d Drivable) {
    d.Drive()
}

func main() {
    car := Car{Brand: "Toyota"}
    bike := Bike{Brand: "Yamaha"}

    StartDriving(car)
    StartDriving(bike)
}

🚩Встраивание интерфейсов

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

package main

import "fmt"

// Определение базового интерфейса
type Printer interface {
    Print()
}

// Определение другого интерфейса, включающего первый
type AdvancedPrinter interface {
    Printer
    Scan()
}

// Реализация структуры, реализующей расширенный интерфейс
type MultiFunctionPrinter struct{}

func (m MultiFunctionPrinter) Print() {
    fmt.Println("Printing...")
}

func (m MultiFunctionPrinter) Scan() {
    fmt.Println("Scanning...")
}

func main() {
    mfp := MultiFunctionPrinter{}
    mfp.Print()
    mfp.Scan()
}

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

🤔 Как можно проверить тип интерфейса?

Тип интерфейса проверяется с помощью type assertion (утверждения типа) или оператора switch. Например, в Go это позволяет выяснить, к какому конкретному типу относится переменная, реализующая интерфейс.

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

🤔 Что такое Prometheus?

Prometheus – это мощная система мониторинга с временными рядами (time series), которая собирает метрики из сервисов, хранит их и позволяет строить графики и отправлять алерты.

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

Pull-модель – сам запрашивает метрики у сервисов (в отличие от push-модели, как в StatsD).
Формат временных рядов – каждая метрика привязана ко времени и меткам (labels).
Язык запросов PromQL – позволяет анализировать и агрегировать метрики.
Автодетектирование сервисов – поддержка Kubernetes, Docker, Consul.
Хранение данных в базе TSDB (Time Series Database).
Гибкая система алертов – интеграция с Alertmanager (уведомления в Slack, Telegram и др.).

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

Экспортеры/сервисы предоставляют метрики через HTTP-эндпоинт (/metrics).
Prometheus сам запрашивает данные по расписанию.
Метрики хранятся в базе TSDB.
Можно строить графики в Grafana или запрашивать данные через API.
Алерты отправляются в Alertmanager при достижении пороговых значений.

🚩Пример метрик в Go
Go-сервис может отдавать метрики через HTTP с помощью 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 main() {
    // Регистрируем метрику
    prometheus.MustRegister(httpRequests)

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

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

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

Пример запроса в PromQL

http_requests_total

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

🤔 Почему пустой интерфейс можно привести к любому типу?

Пустой интерфейс (interface{} в Go) может содержать значения любого типа, так как не накладывает никаких ограничений на структуру данных. Он используется как универсальный контейнер.

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

🤔 Сколько очередей в паттерне?

Паттерн "Очередь" (Queue) в программировании обычно представляет собой структуру данных или архитектурный подход, используемый для обработки сообщений, задач или запросов в определённом порядке (обычно FIFO — "первым вошёл, первым вышел").
Но если рассматривать количество очередей в каком-то конкретном паттерне проектирования, то всё зависит от контекста. Например:

🚩Одиночная очередь (Single Queue)

Все задачи обрабатываются в одной очереди по порядку. Используется, когда важен строгий порядок выполнения. Пример: канал (channel) в Go, куда отправляются задачи для обработки.

🚩Несколько очередей (Multiple Queues)

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

🚩Очередь с пуулом воркеров (Worker Pool Queue)

Есть одна очередь задач, но несколько рабочих (goroutines), которые извлекают задачи и обрабатывают их параллельно.
Уменьшает нагрузку на систему и ускоряет выполнение.

     package main

     import (
         "fmt"
         "sync"
         "time"
     )

     func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
         defer wg.Done()
         for job := range jobs {
             fmt.Printf("Worker %d started job %d\n", id, job)
             time.Sleep(time.Second) // имитация работы
             fmt.Printf("Worker %d finished job %d\n", id, job)
             results <- job * 2
         }
     }

     func main() {
         jobs := make(chan int, 5)
         results := make(chan int, 5)
         var wg sync.WaitGroup

         numWorkers := 3
         for i := 1; i <= numWorkers; i++ {
             wg.Add(1)
             go worker(i, jobs, results, &wg)
         }

         for j := 1; j <= 5; j++ {
             jobs <- j
         }
         close(jobs)

         wg.Wait()
         close(results)

         for res := range results {
             fmt.Println("Result:", res)
         }
     }

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

🤔 Как пустой интерфейс связан с обычным?

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

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

🤔 Что может быть пустым интерфейсом?

Пустой интерфейс interface{} является универсальным контейнером, который может содержать значение любого типа. Это связано с тем, что в Go любой тип автоматически реализует пустой интерфейс, поскольку в нем нет методов, которые нужно реализовать.

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

🚩Примеры

Примитивные типы

package main

import "fmt"

func main() {
    var i interface{}
    i = 42
    fmt.Println(i) // Output: 42

    i = "hello"
    fmt.Println(i) // Output: hello

    i = true
    fmt.Println(i) // Output: true
}

Композитные типы

package main

import "fmt"

func main() {
    var i interface{}

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

    i = map[string]int{"one": 1, "two": 2}
    fmt.Println(i) // Output: map[one:1 two:2]

    type Person struct {
        Name string
        Age  int
    }

    i = Person{Name: "Alice", Age: 30}
    fmt.Println(i) // Output: {Alice 30}
}

Функции

package main

import "fmt"

func main() {
    var i interface{}

    i = func() {
        fmt.Println("Hello from function")
    }

    if f, ok := i.(func()); ok {
        f() // Output: Hello from function
    }
}

Другие интерфейсы

package main

import "fmt"

type Stringer interface {
    String() string
}

type Person struct {
    Name string
    Age  int
}

func (p Person) String() string {
    return fmt.Sprintf("%s (%d years old)", p.Name, p.Age)
}

func main() {
    var i interface{}

    i = Person{Name: "Alice", Age: 30}

    if str, ok := i.(Stringer); ok {
        fmt.Println(str.String()) // Output: Alice (30 years old)
    }
}

🚩Проверка и приведение типа

Утверждение типа

package main

import "fmt"

func main() {
    var i interface{} = 42

    if v, ok := i.(int); ok {
        fmt.Println("Integer:", v) // Output: Integer: 42
    } else {
        fmt.Println("Not an integer")
    }
}

Использование switch для проверки типа

package main

import "fmt"

func printType(i interface{}) {
    switch v := i.(type) {
    case string:
        fmt.Println("String:", v)
    case int:
        fmt.Println("Integer:", v)
    case bool:
        fmt.Println("Boolean:", v)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

func main() {
    printType("hello")      // Output: String: hello
    printType(42)           // Output: Integer: 42
    printType(true)         // Output: Boolean: true
    printType(3.14)         // Output: Unknown type: float64
}

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