Rust и Go стоят на первых двух местах в списке языков, которые разработчики собираются освоить в ближайшие полгода: Rust назвали 10% участников опроса, Go — 8%. Это данные отчёта JetBrains State of Developer Ecosystem 2026, опубликованного 10 ноября. Опрос шёл с мая по июль 2026 года, в итоговую выборку вошли 28 945 разработчиков из 198 стран и регионов.
Новичку эти проценты мало помогают с выбором. Поэтому мы написали одну и ту же небольшую утилиту на Go 1.27.4 и Rust 1.100.0, замерили сборку, посмотрели на первую типичную ошибку в каждом языке и посчитали вакансии на hh.ru. Ниже — код, цифры и вывод команд.
Ключевые выводы
- Утилита из 40–50 строк пишется на обоих языках за вечер. Версия на Rust вышла короче (39 строк против 49), но требует понимать владение и заимствование уже на старте.
- Rust ловит ошибку работы с данными при компиляции и подсказывает исправление. Go ту же по смыслу небрежность компилирует, и программа падает при запуске.
- На hh.ru 16 ноября 2026 года слово Go или Golang было в названии 130 вакансий разработчиков по России, Rust — в 11. Для кандидатов с опытом до трёх лет нашлось 13 вакансий на Go и ни одной на Rust.
- По опросу команды Go, у 81% участников общий опыт разработки больше, чем опыт в Go: язык обычно учат не первым. Официальная книга по Rust тоже рассчитана на тех, кто уже писал код.
Что говорят опросы о тех, кто начинает учить Go и Rust?
Команда Go ежегодно опрашивает своих пользователей. В опросе 2025 года, итоги которого вышли 21 января 2026 года, учтены ответы 5379 человек. 91% довольны языком. При этом у 81% профессионального опыта в разработке больше, чем опыта именно в Go: авторы отчёта называют это сильным свидетельством того, что Go обычно становится не первым языком разработчика. Доля тех, кто пишет на Go меньше года, упала с 21% до 13%. Команда связывает такую динамику со снижением числа стартовых позиций в отрасли и подчёркивает, что это лишь предположение.
Главные жалобы действующих разработчиков на Go тоже полезны новичку. 33% трудно понять, соответствует ли их код принятым в Go практикам; 28% не хватает возможностей из других языков; 26% сложно находить надёжные сторонние модули. В открытых ответах чаще всего упоминали обработку ошибок, перечисления и защиту от обращения по nil.
У Rust свой ежегодный опрос: в конце 2025 года его прошли 7156 человек. По полному отчёту, продуктивно пишущими на Rust себя считают 56,8% ответивших на вопрос об уровне; в 2022 году таких было 42,3%. Тех, кто Rust не использует, спросили о причинах — ответили 268 человек. 31,7% из них выбрали вариант «слишком трудно учить или обучение займёт слишком много времени». Среди проблем у пользователей языка команда опроса первой называет расход ресурсов: медленную компиляцию и занятое место на диске.
Оба опроса проходят среди тех, кто уже пользуется языком или следит за ним, поэтому их результаты нельзя переносить на всех разработчиков. Сравнивать 91% у Go с 56,8% у Rust напрямую нельзя: это ответы на разные вопросы.
Как выглядит одна и та же программа на Go и Rust?
Задача для первого проекта типовая: прочитать текстовый файл, посчитать, сколько раз встречается каждое слово, и вывести пять самых частых. Здесь есть чтение файла, обработка ошибок, словарь и сортировка, то есть всё, с чем новичок столкнётся в первую неделю. Сторонние библиотеки не нужны, хватает стандартной.
Версия на Go, файл main.go:
package main
import (
"bufio"
"fmt"
"os"
"sort"
"strings"
)
func main() {
if len(os.Args) < 2 {
fmt.Fprintln(os.Stderr, "usage: wc <file>")
os.Exit(1)
}
f, err := os.Open(os.Args[1])
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
defer f.Close()
counts := map[string]int{}
sc := bufio.NewScanner(f)
sc.Buffer(make([]byte, 1024*1024), 1024*1024)
for sc.Scan() {
for _, w := range strings.Fields(strings.ToLower(sc.Text())) {
counts[w]++
}
}
if err := sc.Err(); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
words := make([]string, 0, len(counts))
for w := range counts {
words = append(words, w)
}
sort.Slice(words, func(i, j int) bool {
if counts[words[i]] != counts[words[j]] {
return counts[words[i]] > counts[words[j]]
}
return words[i] < words[j]
})
for _, w := range words[:min(5, len(words))] {
fmt.Println(counts[w], w)
}
}
Версия на Rust, файл src/main.rs:
use std::collections::HashMap;
use std::env;
use std::fs::File;
use std::io::{BufRead, BufReader};
use std::process;
fn main() {
let Some(path) = env::args().nth(1) else {
eprintln!("usage: wc <file>");
process::exit(1);
};
let file = match File::open(&path) {
Ok(f) => f,
Err(e) => {
eprintln!("{e}");
process::exit(1);
}
};
let mut counts: HashMap<String, u64> = HashMap::new();
for line in BufReader::new(file).lines() {
let line = match line {
Ok(l) => l,
Err(e) => {
eprintln!("{e}");
process::exit(1);
}
};
for w in line.to_lowercase().split_whitespace() {
*counts.entry(w.to_string()).or_insert(0) += 1;
}
}
let mut words: Vec<(&String, &u64)> = counts.iter().collect();
words.sort_by(|a, b| b.1.cmp(a.1).then(a.0.cmp(b.0)));
for (w, n) in words.iter().take(5) {
println!("{n} {w}");
}
}
Обе программы на одном и том же файле печатают одинаковый результат:
64800 the
49200 to
48400 of
34800 and
30800 go
В версии на Go 49 строк, на Rust — 39. Разница в длине мало что значит: важнее, какие понятия пришлось использовать. В Go это срезы, словарь, проверка if err != nil после каждой операции и defer. В Rust уже в первой программе появляются match по результату операции, ссылки &String в векторе и вызов to_string(), который копирует слово в словарь: без понимания, кто владеет строкой, этот код не написать. Зато в Rust нельзя незаметно пропустить ошибку чтения строки: значение лежит внутри Result, и чтобы его достать, нужно явно выбрать, что делать с ошибкой.
Сколько времени занимает сборка и что получается на выходе?
Окружение: Ubuntu 22.04 в WSL2, процессор AMD Ryzen 9 5900X, Go 1.27.4, rustc и cargo 1.100.0. Каждую сборку запускали по три раза, в таблице указан диапазон. Входной файл для запуска весит 11 МБ и содержит 1,8 млн слов. На машине в это время работали другие задачи, поэтому время запуска плавает; порядок величин это не меняет.
| Что измеряли | Go 1.27.4 | Rust 1.100.0 |
| Команда сборки | go build |
cargo build и cargo build --release |
| Первая сборка с пустым кешем | 3,7–4,5 с | 0,36–0,47 с в отладочном профиле, 0,30–0,36 с в release |
| Пересборка после правки | около 0,4 с | 0,16 с в отладочном профиле |
| Размер исполняемого файла | 2,4 МБ | 5,3 МБ в отладочном профиле, 0,5 МБ в release |
| Обработка файла на 11 МБ | 0,4–0,7 с | 0,2–0,4 с в release, 1,5 с в отладочном профиле |
| Пиковая память при запуске | около 8 МБ | около 2 МБ |
Первая сборка Go дольше, потому что при пустом кеше компилятор собирает нужные пакеты стандартной библиотеки, а Rust получает её уже скомпилированной вместе с тулчейном. После первого раза обе пересборки занимают доли секунды.
Этот замер не показывает известную претензию к Rust. У нашей утилиты нет зависимостей, а в рабочих проектах они есть, и каждую cargo компилирует из исходников. Именно медленную компиляцию участники опроса Rust называют среди главных проблем, и на программе из 39 строк её не увидеть. Обратите внимание и на профили: отладочная сборка Rust на той же задаче работала в несколько раз медленнее, чем release. Go мы собирали с настройками по умолчанию.
На какой ошибке новичок споткнётся первым?
В Rust характерный пример связан с владением. Возьмём пять строк: вектор имён присваиваем другой переменной и затем обращаемся к старой.
fn main() {
let names = vec![String::from("Ann"), String::from("Bob")];
let copy = names;
println!("{}", names.len());
println!("{}", copy.len());
}
Компилятор rustc 1.100.0 программу не соберёт и объяснит почему:
error[E0382]: borrow of moved value: `names`
--> main.rs:4:20
|
2 | let names = vec![String::from("Ann"), String::from("Bob")];
| ----- move occurs because `names` has type `Vec<String>`, which does not implement the `Copy` trait
3 | let copy = names;
| ----- value moved here
4 | println!("{}", names.len());
| ^^^^^ value borrowed here after move
|
help: consider cloning the value if the performance cost is acceptable
|
3 | let copy = names.clone();
| ++++++++
Сообщение показывает строку, где значение переехало, строку, где его пытаются использовать, и вариант исправления. Пока правила владения непривычны, такие сообщения будут появляться часто.
В Go похожая по духу небрежность выглядит иначе. Объявим словарь, но не создадим его:
package main
import "fmt"
func main() {
var counts map[string]int
counts["go"]++
fmt.Println(counts)
}
Команда go build завершается успешно. Сбой происходит при запуске (путь к файлу в выводе мы сократили):
panic: assignment to entry in nil map
goroutine 1 [running]:
main.main()
main.go:7 +0x28
Команда go vet на этом файле тоже ничего не сообщила. Это тот самый случай, о котором пишут участники опроса Go: компилятор не запрещает работать со значением, которое может оказаться nil. Начать писать на Go проще, но часть ошибок он оставляет до запуска и тестов.
Сколько вакансий для начинающих на Go и Rust в России?
Мы посмотрели выдачу hh.ru вечером 16 ноября 2026 года: профессиональная роль «Программист, разработчик», вся Россия, поиск слова только в названии вакансии. Распределение по требуемому опыту показывает сам сайт в фильтрах.
| Требуемый опыт | Go или Golang в названии | Rust в названии |
| Без опыта | 1 | 0 |
| От 1 года до 3 лет | 12 | 0 |
| От 3 до 6 лет | 73 | 10 |
| Более 6 лет | 44 | 1 |
| Всего | 130 | 11 |
Единственная вакансия на Go без опыта в этот день была стажировкой в банке. Все 11 вакансий на Rust требовали от трёх лет опыта; в названиях встречались торговые системы с низкой задержкой, системное ПО и поисковый движок, в трёх случаях Rust стоял рядом с C++.
Это срез одного дня на одном сайте. Он не учитывает вакансии, где язык назван только в описании, и вакансии без слова Go или Rust в названии. Но соотношение показательное: первую работу на Go в России найти трудно, а на Rust объявлений для начинающих в выдаче не было вовсе. По зарплатам Go в верхней группе: в отчёте Хабр Карьеры за первое полугодие 2026 года медиана у разработчиков на Golang составила 325 000 рублей, четвёртое место среди языков. Это медиана по всем уровням, без выделения начинающих. Rust в тексте этого отчёта отдельной строкой не приведён.
Что выбрать для первого проекта?
Выбор зависит от того, зачем вам проект. Это вывод Proglib из замеров и данных выше.
- Нужна первая работа в бэкенде в ближайший год. Берите Go: вакансий на порядок больше, язык небольшой, сборка и тесты входят в стандартную поставку. Учтите, что у 81% участников опроса Go общий опыт разработки больше, чем опыт в этом языке.
- Хотите разобраться, как устроены память и системное программирование, и не торопитесь с трудоустройством. Берите Rust: компилятор будет объяснять ошибки, которые в других языках всплывают при запуске. Закладывайте на вход больше времени.
- Программирование для вас совсем новое. По данным опроса Go, этот язык обычно учат не первым, а официальная книга по Rust во введении предупреждает, что рассчитана на читателя с опытом в другом языке. Проще начать с Python или JavaScript и вернуться к выбору между Go и Rust через несколько месяцев.
- Уже пишете на C или C++. Rust ближе по задачам, и в вакансиях он нередко стоит рядом с C++.
Для самого первого шага у обоих языков есть официальные учебные проекты. У Go это короткое руководство Get started и интерактивный Tour of Go, который проходится в браузере. У Rust во второй главе официальной книги пишут игру «Угадай число», а в двенадцатой — консольную утилиту поиска по файлу, близкую к нашему примеру.
Практичный способ решить за выходные: повторите наш эксперимент на своей задаче. Возьмите утилиту, которая нужна вам самим (например, разбор лога или переименование файлов), и напишите её на обоих языках. После второго вечера обычно понятно, с каким компилятором вам проще договариваться. О том, как читать зарплатные вилки в вакансиях бэкенда, у Proglib есть отдельный материал.
Источники
- https://devecosystem.jetbrains.com/tools-and-trends
- https://blog.jetbrains.com/research/2026/11/state-of-developer-ecosystem-2026/
- https://go.dev/blog/survey2025
- https://blog.rust-lang.org/2026/03/02/2025-State-Of-Rust-Survey-results/
- https://raw.githubusercontent.com/rust-lang/surveys/main/surveys/2025/annual-survey/report/annual-survey-2025-report.pdf
- https://habr.com/ru/specials/1060148/
- https://go.dev/doc/tutorial/getting-started
- https://doc.rust-lang.org/book/ch02-00-guessing-game-tutorial.html
- https://doc.rust-lang.org/book/ch12-00-an-io-project.html
- https://doc.rust-lang.org/book/ch00-00-introduction.html
- https://go.dev/tour/
- https://hh.ru/search/vacancy?text=Rust&search_field=name&professional_role=96&area=113
Комментарии