Представьте: три часа ночи, ваша производственная система рушится, и вы лихорадочно ищете утечку памяти, которая преследует вашу команду несколько недель. Звучит знакомо? Ну что ж, возьмите кофе (или энергетический напиток на ваш выбор), потому что мы собираемся погрузиться в эпическое противостояние, которое назревало в мире системного программирования: Rust против Go.

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

Сказка о двух титанах

Будем честными: и Rust, и Go возникли из-за разочарования существующими языками системного программирования. C++ был мощным, но опасным (как если бы дать бензопилу программисту на кофеине), Java была безопасной, но медленной, а JavaScript… ну, давайте не будем углубляться в системное программирование на JavaScript.

Но вот где всё становится интересно: эти два языка выбрали совершенно разные подходы к решению одних и тех же проблем. Go сказал: «Давайте сделаем всё просто и быстро в разработке». Rust сказал: «Давайте сделаем всё невероятно быстро и невозможно сломать». Это как наблюдать за черепахой и зайцем, только оба бегут с сверхчеловеческой скоростью.

Производительность: цифры не врут (почти)

Здесь всё становится пикантно. Недавние тесты показывают, что оптимизированный код Rust стабильно превосходит оптимизированный код Go примерно на 30% по различным алгоритмам. Но подождите, есть и лучше — в некоторых случаях, например при операциях с бинарными деревьями, Rust может быть быстрее в 12 раз.

Позвольте мне показать вам, как это выглядит на практике:

// Rust: абстракции без затрат
use rayon::prelude::*;
fn process_data_parallel(data: &[i32]) -> Vec<i32> {
    data.par_iter()
        .map(|&x| x * x + 2 * x + 1)
        .collect()
}
fn main() {
    let numbers: Vec<i32> = (1..1_000_000).collect();
    let start = std::time::Instant::now();
    let result = process_data_parallel(&numbers);
    println!("Время обработки Rust: {:?}", start.elapsed());
    println!("Обработано {} элементов", result.len());
}

// Go: простота с goroutine
package main
import (
    "fmt"
    "runtime"
    "sync"
    "time"
)
func processDataParallel(data []int) []int {
    numCPU := runtime.NumCPU()
    chunkSize := len(data) / numCPU
    result := make([]int, len(data))
    var wg sync.WaitGroup
    for i := 0; i < numCPU; i++ {
        wg.Add(1)
        go func(start, end int) {
            defer wg.Done()
            for j := start; j < end && j < len(data); j++ {
                result[j] = data[j]*data[j] + 2*data[j] + 1
            }
        }(i*chunkSize, (i+1)*chunkSize)
    }
    wg.Wait()
    return result
}
func main() {
    numbers := make([]int, 1000000)
    for i := range numbers {
        numbers[i] = i + 1
    }
    start := time.Now()
    result := processDataParallel(numbers)
    fmt.Printf("Время обработки Go: %v\n", time.Since(start))
    fmt.Printf("Обработано %d элементов\n", len(result))
}

Версия Rust использует ящик rayon для параллельной обработки данных без дополнительных затрат времени выполнения, в то время как Go использует goroutine с более явным подходом. В реальных тестах версия Rust обычно работает примерно в 1,5 раза быстрее.

Управление памятью: философское разделение

Здесь всё становится действительно интересно. Go и Rust подходят к безопасности памяти как два разных стиля воспитания.

Go — это снисходительный родитель: «Вот, возьми этот сборщик мусора. Он будет автоматически убирать за тобой. Не беспокойся о 10% потери производительности — мы справимся».

Rust — это строгий родитель: «Хочешь память? Докажи мне во время компиляции, что ты не будешь её злоупотреблять. Никаких затрат времени выполнения, но ты должен следовать правилам».

Позвольте мне проиллюстрировать это классическим примером:

// Rust: система владения предотвращает гонки данных во время компиляции
use std::thread;
use std::sync::{Arc, Mutex};
fn rust_safe_sharing() {
    let data = Arc::new(Mutex::new(vec![1, 2, 3, 4, 5]));
    let mut handles = vec![];
    for i in 0..3 {
        let data_clone = Arc::clone(&data);
        let handle = thread::spawn(move || {
            let mut data = data_clone.lock().unwrap();
            data.push(i);
            println!("Поток {} добавил: {}", i, i);
        });
        handles.push(handle);
    }
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Окончательные данные: {:?}", data.lock().unwrap());
}

// Go: обнаружение гонок во время выполнения и более простой синтаксис
package main
import (
    "fmt"
    "sync"
)
func goSafeSharing() {
    var data []int
    var mu sync.Mutex
    var wg sync.WaitGroup
    data = []int{1, 2, 3, 4, 5}
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go func(val int) {
            defer wg.Done()
            mu.Lock()
            data = append(data, val)
            fmt.Printf("Горутина %d добавила: %d\n", val, val)
            mu.Unlock()
        }(i)
    }
    wg.Wait()
    fmt.Printf("Окончательные данные: %v\n", data)
}

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

Опыт разработчика: скорость против безопасности

Вот мой спорный вывод: Go делает вас более продуктивным в краткосрочной перспективе, но Rust делает вас более уверенным в долгосрочной.

Когда я прототипирую или создаю быстрый микросервис, Go — мой выбор (каламбур intended). Время компиляции молниеносно быстрое, синтаксис чистый, и я могу запустить что-то за считанные минуты. Но когда я создаю что-то, что должно работать безупречно в течение многих лет, обрабатывать огромный масштаб или взаимодействовать с оборудованием, Rust становится моим оружием выбора.

Давайте посмотрим на реальный пример HTTP-сервера:

// Rust с Actix Web — производительный зверь
use actix_web::{web, App, HttpResponse, HttpServer, Result};
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize)]
struct User {
    id: u64,
    name: String,
    email: String,
}
async fn get_user(path: web::Path<u64>) -> Result<HttpResponse> {
    let user_id = path.into_inner();
    // Имитация поиска в базе данных
    let user = User {
        id: user_id,
        name: "John Doe".to_string(),
        email: "[email protected]".to_string(),
    };
    Ok(HttpResponse::Ok().json(user))
}
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/user/{id}", web::get().to(get_user))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

// Go с Gin — удобный для разработчиков
package main
import (
    "net/http"
    "strconv"
    "github.com/gin-gonic/gin"
)
type User struct {
    ID    uint64 `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}
func getUser(c *gin.Context) {
    idStr := c.Param("id")
    id, err := strconv.ParseUint(