Golang | Вопросы собесов

В чем отличия http 1.1 и http 2 ? Спросят с вероятностью 17% HTTP/1.1 и HTTP/2 — это версии протокола HTTP, каждая из которых имеет свои особенности и улучшения по сравнению с предыдущими версиями. Важные различия между этими версиями включают следующие аспекты: 1⃣Мультиплексирование HTTP/1.1: ✅Поддерживает одновременное открытие нескольких TCP соединений (обычно 6-8), что позволяет загружать несколько ресурсов параллельно. Однако каждое соединение может обрабатывать только один запрос за раз, что приводит к задержкам из-за блокировки очереди (head-of-line blocking). HTTP/2: ✅Вводит мультиплексирование, позволяющее отправлять множество запросов и ответов асинхронно через одно единственное TCP соединение. Это значительно уменьшает задержки и улучшает производительность при загрузке страниц с большим количеством ресурсов. 2⃣Бинарный протокол HTTP/1.1: ✅Является текстовым протоколом, что означает, что запросы и ответы форматируются в виде читаемого текста. HTTP/2: ✅Бинарный протокол, который делает передачу данных более эффективной и менее подверженной ошибкам в синтаксическом анализе. Бинарный формат упрощает реализацию парсеров и уменьшает размер передаваемых данных. 3⃣Сжатие заголовков HTTP/1.1: ✅Заголовки передаются без сжатия, что может привести к значительному объему передаваемых данных, особенно если одни и те же заголовки отправляются повторно с каждым запросом. HTTP/2: ✅Использует механизм сжатия заголовков HPACK, который уменьшает избыточность заголовков, сжимая их перед отправкой. Это особенно эффективно для повторяющихся запросов к одним и тем же серверам. 4⃣Приоритизация запросов HTTP/1.1: ✅Не поддерживает приоритизацию запросов, из-за чего браузеры должны использовать эвристики для управления приоритетами ресурсов. HTTP/2: ✅Поддерживает явную приоритизацию запросов, позволяя клиенту указывать приоритет обработки ресурсов, что делает загрузку страниц более эффективной. 5⃣Server Push HTTP/1.1: ✅Не имеет возможности "server push", при котором сервер инициативно отправляет ресурсы клиенту, даже если они не были явно запрошены. HTTP/2: ✅Включает функцию "server push", позволяя серверам отправлять ресурсы клиенту в предвидении будущих запросов, что может ускорить загрузку веб-страниц. HTTP/2 представляет собой значительное улучшение по сравнению с HTTP/1.1, предлагая улучшенную производительность, эффективность и возможности. Эти улучшения направлены на ускорение загрузки веб-страниц и оптимизацию общения между клиентами и серверами. 👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент 🔐 База собесов | 🔐 База тестовых

Что делает команда килл в linux ? Спросят с вероятностью 17% Команда kill используется для отправки сигналов процессам. С помощью этой команды можно управлять поведением процессов, включая их корректное завершение, принудительное закрытие и другие действия, зависящие от конкретного сигнала. Основной синтаксис команды kill выглядит так:

kill [options] <pid>

Здесь <pid> обозначает идентификатор процесса (process ID), которому нужно отправить сигнал. По умолчанию, если сигнал не указан, команда kill отправляет сигнал SIGTERM (15), который просит процесс корректно завершиться. Существует несколько сигналов, которые часто используются с командой kill: ✅SIGTERM (15): Корректное завершение процесса. Позволяет процессу корректно закрыть открытые файлы, освободить ресурсы и т. д. ✅SIGKILL (9): Немедленное принудительное завершение процесса. ОС немедленно завершает процесс, не давая ему возможности освободить ресурсы или корректно завершить работу. ✅SIGHUP (1): Обычно используется для перезапуска процессов, например, демонов или сервисов. ✅SIGINT (2): Сигнал прерывания, аналогичный нажатию Ctrl+C в терминале. Для отправки сигнала SIGTERM процессу с PID 1234:

kill 1234

Для принудительного завершения процесса (если он не реагирует на SIGTERM):

kill -9 1234

Для отправки сигнала SIGHUP для перезагрузки конфигурации сервиса:

kill -1 1234

Использование с pgrep и pkill Могут использоваться для упрощения поиска и завершения процессов по имени или другим критериям: ✅pgrep возвращает список PID'ов по заданным критериям. ✅pkill отправляет сигналы процессам, удовлетворяющим заданным критериям. Например, если необходимо завершить все процессы с именем nginx:

pkill nginx

Команда kill — это мощный инструмент для управления процессами через отправку сигналов. Она позволяет не только безопасно завершать процессы, но и управлять более сложным поведением системы, таким как перезагрузка или прерывание работы программ. Это ключевой инструмент для администрирования и управления процессами. 👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент 🔐 База собесов | 🔐 База тестовых

Как проверить тип переменной в среде выполнения ? Спросят с вероятностью 8% Существует несколько способов проверки типа переменной в среде выполнения. Вот методы, которые помогут вам определить тип переменной во время выполнения программы. 1️⃣Использование reflect пакета Пакет reflect предоставляет мощные инструменты для работы с типами переменных во время выполнения.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x interface{} = 42
    fmt.Println("Type:", reflect.TypeOf(x))
    fmt.Println("Value:", reflect.ValueOf(x))
}

Здесь: ✅reflect.TypeOf(x) возвращает тип переменной x. ✅reflect.ValueOf(x) возвращает значение переменной x. 2️⃣Использование типа-утверждения (type assertion) Тип-утверждение позволяет проверить, является ли переменная конкретным типом, и получить значение этого типа.

package main

import "fmt"

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

    if str, ok := x.(string); ok {
        fmt.Println("x is a string:", str)
    } else {
        fmt.Println("x is not a string")
    }
}

Здесь: ✅x.(string) пытается утверждать, что x имеет тип string. ✅Если утверждение верно, переменная str будет содержать значение типа string, а ok будет равно true. ✅Если утверждение неверно, ok будет равно false. 3️⃣Использование оператора switch по типам Go поддерживает использование оператора switch для проверки типа переменной.

package main

import "fmt"

func main() {
    var x interface{} = 3.14

    switch v := x.(type) {
    case int:
        fmt.Println("x is an int:", v)
    case float64:
        fmt.Println("x is a float64:", v)
    case string:
        fmt.Println("x is a string:", v)
    default:
        fmt.Println("x is of an unknown type")
    }
}

В этом примере: ✅Оператор switch по типу переменной x. ✅В каждой ветке проверяется, является ли x определенным типом (int, float64, string). ✅Переменная v получает значение типа, если проверка успешна. Проверка типа переменной может быть выполнена с использованием пакета reflect, типа-утверждения (type assertion) и оператора switch по типам. Каждый метод имеет свои особенности и может быть полезен в различных сценариях. 👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент 🔐 База собесов | 🔐 База тестовых

Пс.. Тут два С++ сеньора создали канал, где простым языком поясняют за плюсы, метапрограммирование, фишки новых стандартов, алгоритмы, вопросы с собеседований и другие непонятные штуки из современного программирования на С++. Прямо сейчас Вы можете бесплатно забрать гайды по собеседованиям, по категориям выражений и мув-семантике и по ключевому слову inline. Все найдете в закрепе канала. Подписывайтесь, чтобы пояснять друзьям за оптимизации компилятора, о которых вам никто не расскажет: Грокаем С++

Как завершить много горутин ? Спросят с вероятностью 17% Завершение множества горутин требует организованного подхода, так как управление ими не предоставляет прямых средств для их остановки. Основные практики включают использование каналов для сигнализации о необходимости завершения, контекстов для управления временем выполнения и ограничениями, а также синхронизации с помощью sync.WaitGroup. Вот каждый из этих методов. 1⃣Использование каналов для управления горутинами Каналы могут использоваться для отправки сигналов горутинам о том, что им следует завершить свою работу. Это один из наиболее часто используемых подходов, так как он прост в реализации и очень эффективен.

package main

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

func worker(stopCh <-chan struct{}, wg *sync.WaitGroup, id int) {
    defer wg.Done()
    for {
        select {
        case <-stopCh:
            fmt.Printf("Worker %d stopping\n", id)
            return
        default:
            // выполнение полезной работы
            fmt.Printf("Worker %d working\n", id)
            time.Sleep(time.Second)
        }
    }
}

func main() {
    var wg sync.WaitGroup
    stopCh := make(chan struct{})

    // запуск горутин
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go worker(stopCh, &wg, i)
    }

    // остановка горутин после 3 секунд
    time.Sleep(3 * time.Second)
    close(stopCh) // отправка сигнала всем горутинам остановиться
    wg.Wait()    // ожидание завершения всех горутин
}

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

package main

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

func worker(ctx context.Context, wg *sync.WaitGroup, id int) {
    defer wg.Done()
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("Worker %d stopping\n", id)
            return
        default:
            // выполнение полезной работы
            fmt.Printf("Worker %d working\n", id)
            time.Sleep(time.Second)
        }
    }
}

func main() {
    var wg sync.WaitGroup
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)

    // запуск горутин
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go worker(ctx, &wg, i)
    }

    wg.Wait() // ожидание завершения всех горутин
    cancel()  // убедиться, что все ресурсы освобождены
}

Для остановки множества горутин используются каналы или контексты. Оба метода позволяют элегантно и безопасно управлять жизненным циклом параллельных процессов, минимизируя риски вроде утечек памяти или "зомби" горутин. Ключевым моментом является выбор подхода, который лучше всего подходит для структуры и требований вашего приложения. 👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент 🔐 База собесов | 🔐 База тестовых

🔥Тесты для подготовки к собеседованию🔥 Выбери своё направление: 1. Frontend 2. Python 3. Java 4. Тестировщик QA 5. Data Science 6. DevOps 7. C# 8. С/C++ 9. Golang 10. PHP 11. Kotlin 12. Swift

Как тестировать распределённую систему ? Спросят с вероятностью 8% Тестирование распределённых систем является сложной задачей, требующей использования различных стратегий и инструментов для обеспечения надежности, производительности и корректности работы всей системы. Ниже представлены основные подходы и методы, которые можно использовать для тестирования распределённых систем. Основные типы 1️⃣Модульное тестирование (Unit Testing): ✅Тестирование отдельных компонентов или функций системы в изоляции. ✅Использование моков (mocking) и заглушек (stubbing) для имитации поведения зависимостей. 2️⃣Интеграционное тестирование (Integration Testing): ✅Тестирование взаимодействия между различными компонентами системы. ✅Проверка корректности интеграции и обмена данными между модулями. 3️⃣Системное тестирование (System Testing): ✅Тестирование всей системы в целом. ✅Проверка выполнения функциональных и нефункциональных требований. 4️⃣Тестирование производительности (Performance Testing): ✅Оценка производительности системы под нагрузкой. ✅Использование нагрузочного тестирования (load testing) и стресс-тестирования (stress testing). 5️⃣Тестирование устойчивости (Resilience Testing): ✅Проверка способности системы восстанавливаться после сбоев. ✅Имитация отказов компонентов и проверка реакции системы. 6️⃣Тестирование безопасности (Security Testing): ✅Поиск уязвимостей и проверка защиты данных. ✅Использование инструментов для анализа безопасности и проведения пентестов (penetration testing). Подходы и методы 1️⃣Использование автоматизированных тестов: ✅Разработка автоматизированных тестов для различных уровней тестирования (модульные, интеграционные, системные). ✅Использование фреймворков для тестирования, таких как JUnit, pytest, Go testing и другие. 2️⃣Контейнеризация и оркестрация: ✅Использование контейнеров (Docker) и систем оркестрации (Kubernetes) для создания изолированных и воспроизводимых тестовых окружений. ✅Имитация различных условий и сценариев работы распределённой системы. 3️⃣Использование моков и заглушек: ✅Создание моков и заглушек для имитации поведения зависимостей и компонентов, которые сложно или дорого тестировать напрямую. ✅Использование библиотек, таких как Mockito, GoMock, WireMock и других. 4️⃣Нагрузочное и стресс-тестирование: ✅Проведение нагрузочного тестирования для оценки производительности системы под реальными условиями. ✅Использование инструментов, таких как JMeter, Gatling, Locust и других. 5️⃣Тестирование устойчивости: ✅Проведение тестов на отказоустойчивость, имитируя сбои компонентов и сетевые проблемы. ✅Использование инструментов, таких как Chaos Monkey, Gremlin и других для проведения хаос-инжиниринга. 6️⃣Мониторинг и логирование: ✅Настройка систем мониторинга и логирования для сбора данных о состоянии и производительности системы. ✅Использование инструментов, таких как Prometheus, Grafana, ELK Stack и других. Использование Docker и Kubernetes

# Пример файла конфигурации Kubernetes для тестового окружения
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-app:latest
        ports:
        - containerPort: 8080

Тестирование распределённых систем требует комплексного подхода, включающего модульное, интеграционное, системное, производственное, устойчивое и безопасное тестирование. Использование автоматизированных тестов, контейнеризации, оркестрации, моков, нагрузочного тестирования, хаос-инжиниринга и мониторинга помогает обеспечить надёжность и производительность системы. 👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент 🔐 База собесов | 🔐 База тестовых

Привет! Ты сейчас ищешь работу? Если да, то у меня для тебя классные новости. Мы с Максом решили провести вебинар на тему поиска работы и того, как быстрее получить оффер. Зачем? Да потому что найти работу просто откликаясь на вакансии теперь практически нереально. На Junior вакансии откликаются по 1500 кандидатов. 1500 человек, Карл... Вопрос: Как искать работу в таких условиях? Ответ: Нужно менять подходы, и использовать новые способы поиска работы. А вот какие способы, и как искать работу в 2024 году, расскажет мой товарищ - Макс, который помогает разработчикам с трудоустройством. Он расскажет тебе как ПРАВИЛЬНО откликаться на вакансии, на что смотрят рекрутеры, и как ты должен быть упакован, чтобы получить работу в это непростое время. 🗓 Когда? Во вторник – 18 июня, в 19:00 по мск. 🎁 После регистрации он также обещал прислать: 1) Анализ рынка труда. 2) Разбор кейсов тех, кто сейчас находит работу. 3) Пошаговый план, что нужно делать, чтобы прийти к оферу. 👉 Записаться на вебинар по поиску работы.

Чем горутины отличаются от тредов ? Спросят с вероятностью 17% Горутины и потоки (треды) в традиционном понимании операционных систем — это две различные концепции параллельного выполнения кода, каждая из которых имеет свои особенности и преимущества. Вот ключевые различия между ними. 1⃣Модель управления Горутины — это легковесные "зеленые" потоки, управляемые Go runtime. Они не являются потоками операционной системы, и Go runtime отвечает за их планирование и выполнение на доступных физических потоках. Это позволяет создавать тысячи и даже миллионы горутин в рамках одного приложения с относительно небольшими затратами памяти и CPU. Треды — это потоки выполнения, управляемые непосредственно операционной системой. Каждый тред занимает значительно больше ресурсов, чем горутина, особенно в плане памяти и времени на создание и управление. Треды более подходят для задач, требующих высокой вычислительной мощности и прямого взаимодействия с операционной системой. 2⃣Затраты ресурсов Горутины потребляют гораздо меньше памяти по сравнению с тредами. Например, стек горутины начинается с нескольких килобайт, что значительно уменьшает затраты при масштабировании. Треды требуют большего количества памяти для каждого стека, обычно начиная от нескольких сотен килобайт до мегабайтов. Это ограничивает количество потоков, которые могут быть активными одновременно без значительного увеличения затрат на ресурсы. 3⃣Масштабируемость Горутины могут масштабироваться до большого количества параллельных задач благодаря меньшим требованиям к ресурсам и управлению со стороны runtime Go. Треды ограничены в масштабируемости физическими ресурсами системы и более высокими затратами на управление. 4⃣Контекст переключения Горутины имеют намного более эффективный контекст переключения, так как 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")
}

Этот пример демонстрирует запуск двух задач параллельно: главная функция main() запускает say("Hello") в горутине, позволяя ей выполняться одновременно с say("World"). Горутины — это эффективный и легковесный способ реализации параллелизма, позволяющий управлять большим количеством задач с минимальными затратами ресурсов. В отличие от них, треды — это более тяжеловесные элементы, управляемые операционной системой, требующие больше ресурсов и времени для управления. Горутины идеально подходят для создания высокопроизводительных и масштабируемых приложений. 👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент 🔐 База собесов | 🔐 База тестовых

Почему тебя не зовут на интервью? Исправь это в своем резюме… Получить приглашение на интервью сейчас сложнее, чем с нуля обучиться разработке. И к сожалению, это не шутка. Скорее всего только 1-2% работодателей сейчас позовут тебя на интервью. Это статистика, которую мы собирали по 10.000 откликам. Но над этой цифрой можно и нужно работать. Если правильно оформить свое резюме, и поменять свою стратегию с откликами, то конверсию можно увеличить до 10%. Т.е почти в 10 раз! Как это сделать? 1. Проверить свое резюме по нашему чек листу, и внести в него то, чего будет не хватать. 2. Поменять свой подход к поиску работы, ведь одними откликами на hh.ru сыт не будешь. 18 июня, в 18:00 по москве, мы вместе с Максом из CodeReview проведем вебинар на тему эффективного поиска работы в 2024 году. На нем Макс покажет как сейчас нужно искать работу. В прямом эфире. А также раскроет что именно нужно писать в свое резюме, чтобы оно ПРОДАВАЛО. Получить чек лист по составлению резюме, а также зарегистрироваться на вебинар можно по этой ссылке. Регистрируйся сейчас и увидимся 18 июня, в 18:00 по мск. 👉 Зарегистрироваться и получить чек-лист по резюме.