🔥 Go 1.23 за 23 минуты — бесплатный мини-курс от Matt Boyle, включающий все ключевые моменты новой версии языка.

☑️ Вы узнаете про:
• Итераторы. Что это такое и что вам нужно знать?
• Изменения в пакетах slice и map.
• Как новый пакет unique может помочь оптимизировать использование памяти.
• В чем заключается новое изменение телеметрии и как его можно (по желанию) включить.

🚀 Ускорьте свою базу данных: 7 проверенных методов масштабирования и оптимизации

Масштабирование улучшает производительность и повышает надежность систем хранения данных путем оптимизации использования ресурсов и распределения нагрузки. В этой статье мы рассмотрим 7 эффективных методов масштабирования и оптимизации базы данных.

🔗 Читать статью
🔗 Зеркало

💡 Кстати, в Go 1.23 представлена ​​новая функция Chunk, которую можно использовать для разделения слайса на подслайсы.

▶️ Вывод:

Product list 0 [TV Fridge]
Product list 1 [Washing Machine Dish Washer]

🔧 Компилятор своими руками: краткий гид для начинающих

В этой статье мы разберем анатомию простейшего компилятора: лексер, парсер и LLVM. Вы узнаете, как эти компоненты взаимодействуют для преобразования исходного кода в исполняемый файл.

🔗 Ссылка на статью

🛠️💥 Использование Go для всего

Зачем использовать 10 инструментов, если можно освоить один? Познакомьтесь с соло-разработчиком Маркусом, который превратил Go в свой швейцарский армейский нож. От CLI до игр для Nintendo Switch — Go делает все!

👉 Читать

Вы наверняка знакомы со «стандартным» способом ветвления кода в зависимости от заданного значения:

switch a {
    case 1: 
        fmt.Println("1")
    case 2:
        fmt.Println("2")
    default:
        fmt.Println("default")
}

Так работает switch в Go и во многих других языках (за исключением того, что в Go не происходит перехода к последующим case).

Но оператор switch может делать больше. Вот несколько кейсов.

1. Несколько значений в одном case.

В case можно указать несколько значений для сопоставления:

switch a {
    case 1: 
        fmt.Println("1")
    case 2, 3, 4:
        fmt.Println("2, 3 или 4")
//  case 1,2:  // ошибка: дублирование case 1, дублирование case 2
//      fmt.Println("1 или 2")
}

Заданное значение может использоваться только в одном блоке case. Дублирование значений в case вызовет ошибку.

2. Инициализатор, как в цикле for.

Вы можете инициализировать значение перед использованием его в switch. Область видимости переменной a ограничена конструкцией switch:

switch a := f(); a {
    case 1: 
        fmt.Println("1")
    case 2:
        fmt.Println("2")
}

3. Нет выражения switch, но есть выражения case.

case не ограничен статическими значениями. Если вы опустите выражение switch, вы можете использовать выражения для каждого case:

switch {
    case a == 1: 
        fmt.Println("1")
    case a >=2 && a <= 4:
        fmt.Println("2")
    case a <= 5:
        fmt.Println("3")
}

Если текущее значение a совпадает более чем с одним case, выбирается первый подходящий.

4. Переключение по типу переменной.

Если ваш код получает значение интерфейса из какого-то источника, вы можете использовать переключение по типу, чтобы проверить фактический тип этого значения:

switch v := a.(type) {
    case int: 
        fmt.Println("a — это int:", v)
    case string, []byte:
        fmt.Println("a — это string:", v)
}

5. Переключение по типу параметра.

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

func do[T comparable](a any) {
    switch v := a.(type) {
    case int:
        fmt.Println("a — это int:", v)
    case T:
        fmt.Printf("a — это %T: %v", v, v)
    case []T:
        fmt.Println("a — это срез:", v)
    case []byte:
        fmt.Println("a — это срез байт:", v)
    }
}

func main() {
    do[bool](a)
    do[bool](true)
    do[int]([]int{1, 2, 3})
}

Как и с выражениями case, если фактический тип a совпадает с несколькими case, выбирается первый подходящий.

👉 Go Playground

#tip

❗Вакансии «Библиотеки программиста» — ждем вас в команде!

Мы постоянно растем и развиваемся, поэтому создали отдельную страницу, на которой будут размещены наши актуальные вакансии. Сейчас мы ищем:
👉авторов в наше медиа proglib.io
👉контент-менеджеров для ведения телеграм-каналов

Подробности тут

Мы предлагаем частичную занятость и полностью удаленный формат работы — можно совмещать с основной и находиться в любом месте🌴

Ждем ваших откликов 👾

🐘🧠 Оптимизация использования памяти в PostgreSQL: секреты профессионалов

Сложные (и многочисленные) операции в базе данных требуют солидного объема оперативной памяти — например, для создания набора результатов PostgreSQL обычно приходится:

🔹 Выполнить поиск по индексу.
🔹 Извлечь связанные строки из одной или нескольких таблиц.
🔹 Объединить, отфильтровать, агрегировать и отсортировать кортежи в пригодный для использования результат.

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

🔹 Как грамотно оптимизировать использование доступной памяти?
🔹 В каком соотношении распределить ОЗУ между несколькими типами памяти, которые необходимы PostgreSQL для эффективной работы?
🔹 Как предотвратить защитное завершение операционной системой процесса PostgreSQL, который использует слишком много памяти?

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

Поэтому в этой статье мы сведем всю мудрость экспертов к конкретным шагам, которые помогут максимально эффективно распорядиться доступной памятью.

🔗 Читать статью
🔗 Зеркало