Вышел Go 1.24 (интерактивные примеры тут)

Производительность

Снижение нагрузки на CPU на 2-3% благодаря:
- Новой реализации встроенных map на основе Swiss Tables
- Более эффективному выделению памяти для малых объектов
- Новой внутренней реализации mutex в runtime

Обобщенные псевдонимы типов

Теперь можно создавать параметризованные псевдонимы типов, например:

type Set[T comparable] = map[T]bool

Слабые указатели

Добавлен новый пакет weak, который предоставляет weak pointers – указатели, которые не препятствуют сборке мусора. Это полезно для реализации кэшей и других структур данных, где нужно избежать утечек памяти.

Улучшенные финализаторы

Представлена новая функция runtime.AddCleanup, которая является более гибкой и эффективной альтернативой runtime.SetFinalizer. Она позволяет:

- Прикреплять несколько функций очистки к одному объекту
- Работать с внутренними указателями
- Избегать утечек памяти при циклических ссылках

Ограниченный доступ к файловой системе

Новый тип os.Root позволяет ограничить файловые операции определенной директорией, что полезно для безопасной работы с файлами.

// Пример использования os.Root
root, err := os.OpenRoot("/path/to/dir")
if err != nil {
    log.Fatal(err)
}

// Операции ограничены директорией
f, err := root.Open("file.txt")
if err != nil {
    log.Fatal(err)
}

Улучшения для тестирования

Добавлен метод testing.B.Loop, который предоставляет более простой и надежный способ написания бенчмарков:

func BenchmarkMyFunc(b *testing.B) {
    // Вместо for i := 0; i < b.N; i++
    for b.Loop() {
        // код бенчмарка
    }
}

Новый пакет testing/synctest позволяет тестировать код с временными операциями, используя синтетические часы вместо реального времени.


Криптография

Добавлены новые криптографические пакеты:

crypto/sha3 - реализация SHA-3
crypto/hkdf - реализация HKDF
crypto/pbkdf2 - реализация PBKDF2


Работа с JSON

Добавлена новая опция omitzero для тегов структур, которая позволяет пропускать нулевые значения при сериализации в JSON. В отличие от omitempty, она работает корректно с time.Time и другими типами, имеющими метод IsZero().
Инструментарий
Go модули теперь могут отслеживать зависимости от исполняемых файлов с помощью директив tool в go.mod. Команды go build, go install и go test получили флаг -json для вывода результатов в формате JSON.

@crossjoin

Lazygit - простой консольный UI для git-комманд, написанный на Go

https://github.com/jesseduffield/lazygit

Да-да, в очередной раз я признаюсь в любви утилитам с минималистичным консольным (графическим) интерфейсом.

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

Но вообще, при работе с гитом, мне нравится гибридный вариант - сложные действия выполняю в хорошем GUI интерфейсе, а более простые текстом в терминале (особенно удобно с плагином oh my zsh).

#repo #terminal_ui

Тестирование конкурентного кода с помощью testing/synctest

https://go.dev/blog/synctest

Damien Neil из Go team рассказал про новый (экспериментальный) пакет testing/synctest для тестирования конкурентного кода, который доступе с версии Go 1.24

Экспериментальный — значит, он доступен только при GOEXPERIMENT=synctest

В чём суть:
Вместо ненадёжных sleep'ов и таймаутов для проверки асинхронных операций, пакет предлагает детерминированный подход. Весь тестируемый код выполняется в изолированном окружении - bubble. В этом окружении время виртуальное и продвигается только когда все горутины заблокированы. То есть, мы точно знаем, когда все горутины достигли точки блокировки с помощью Wait()

Никаких больше фейковых часов и моков time.Now() - всё работает из коробки.

При этом, у пакета всего два метода: synctest.Run() и synctest.Wait()

Пример до:

// Классический подход с time.Sleep
func TestAfterFunc(t *testing.T) {
    calledCh := make(chan struct{})
    context.AfterFunc(ctx, func() {
        close(calledCh)
    })

    // Ждем и надеемся...
    time.Sleep(10 * time.Millisecond)
    if called {
        t.Fatal("called too early")
    }
}

После:

// С synctest - детерминированно и без слипов
func TestAfterFunc(t *testing.T) {
    synctest.Run(func() {
        funcCalled := false
        context.AfterFunc(ctx, func() {
            funcCalled = true
        })

        synctest.Wait() 
        if funcCalled {
            t.Fatal("called too early")
        }
    })
}

#go_official #go_experimental

Swiss Tables новая реализация map — Go 1.24

https://go.dev/blog/swisstable

Перевод

Как вы наверняка уже знаете, в Go 1.24 встроенная реализация map была полностью переработана и теперь основана на Swiss Table. В этой статье Michael Pratt (один из авторов языка) разобрал какие преимущества даёт новая реализация по сравнению с традиционными хеш‑таблицами.

#go_official

Уровни оптимизации кода на Go: начинай с главного

https://habr.com/ru/companies/vk/articles/902820/

Автор разделяет оптимизацию на три уровня:

1. Макровзаимодействия — HTTP / gRPC / SQL, старт процессов (десятки‑сотни миллисекунд).

2. Микровзаимодействия — syscalls, WebSocket внутри открытого соединения (микросекунды).

3. Инструкции CPU — циклы, копирование памяти, сортировки (наносекунды).

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

Цитата:

Оптимизируя код, действуйте в следующей последовательности: сначала оптимизируйте крупные операции, затем переходите к более мелким. Начните с удаления каких-то операций, потом уменьшайте сложность, и только в конце — распараллеливайте. Так вы потратите меньше времени на увеличение скорости работы вашего приложения. Не придется запускать профилировщик на каждый чих, потому что можно просто посмотреть и сразу понять, что надо делать.

Статья короткая, но неплохо расставляет приоритеты. Рекомендую, особенно джунам, которые любят начинать оптимизацию с make(slice, 0, cap)

Ну и, к слову про оптимизацию, не забывайте классику

#article

Retry в Go: От граблей к дзену отказоустойчивости

https://habr.com/ru/articles/903576/

Автор затронул хорошую тему — ретраи крайне важная штука, но многие недооценивают их сложность.

Скажем, если вы не знакомы с понятиями Exponential Backoff и Jitter, то точно стоит прочитать. Также разобраны и более глубокие моменты.

#article