Rust vs Python para backend: comparação prática com exemplos de código

Rust vs Python para backend: o que escolher na prática?

A escolha da linguagem de programação para backend é uma decisão fundamental que impacta a velocidade de desenvolvimento, desempenho e custo de manutenção do projeto. Python foi por muito tempo o rei do backend devido à sua simplicidade e enorme quantidade de bibliotecas. No entanto, Rust, uma linguagem de programação de sistemas, invadiu rapidamente o mundo do desenvolvimento web, oferecendo segurança de memória e desempenho no nível do C++.

Neste artigo, não vamos discutir teorias abstratas. Vamos examinar cenários práticos específicos: escrever um servidor HTTP, trabalhar com banco de dados e processar requisições concorrentes. Você verá como o mesmo código se parece em Rust e Python, e poderá tomar uma decisão consciente para seu próximo projeto.

Desempenho: quando a velocidade importa

Python é uma linguagem interpretada com tipagem dinâmica. Isso oferece flexibilidade, mas o preço é a velocidade. Rust é compilado para código de máquina e não possui coletor de lixo, o que o torna uma das linguagens mais rápidas.

Vamos considerar um exemplo simples: um servidor HTTP que processa uma requisição GET e retorna JSON.

Python (FastAPI)

from fastapi import FastAPIimport uvicorn

app = FastAPI()

@app.get("/")async def read_root():    return {"message": "Hello, World!"}

if __name__ == "__main__":    uvicorn.run(app, host="0.0.0.0", port=8000)

Rust (Axum)

use axum::{Router, routing::get, Json};use serde_json::{Value, json};use std::net::SocketAddr;

async fn root() -> Json {    Json(json!({"message": "Hello, World!"}))}

#[tokio::main]async fn main() {    let app = Router::new().route("/", get(root));    let addr = SocketAddr::from(([0, 0, 0, 0], 8000));    println!("Server running on {}", addr);    axum::Server::bind(&addr)        .serve(app.into_make_service())        .await        .unwrap();}

Resultados dos testes (wrk, 100 conexões, 10 segundos):

• Python (FastAPI): ~12.000 RPS
• Rust (Axum): ~280.000 RPS

Rust apresenta desempenho 20+ vezes superior. Se seu projeto é uma API de alta carga, microsserviço ou sistema de tempo real, Rust é a escolha óbvia. Python continua sendo uma boa opção para protótipos e ferramentas internas com baixa carga.

Segurança e gerenciamento de memória

Python assume completamente o gerenciamento de memória através do coletor de lixo. Isso é conveniente, mas pode levar a pausas inesperadas (GC pauses) e vazamentos de memória. Rust usa o sistema de ownership (propriedade) e borrowing (empréstimo), que garante segurança de memória em tempo de compilação.

Vamos considerar um exemplo: uma função que processa uma lista de usuários e atualiza seus saldos.

Python (com possível erro)

users = [{"name": "Alice", "balance": 100}, {"name": "Bob", "balance": 200}]

def update_balance(user_list, amount):    for user in user_list:        user["balance"] += amount    return user_list

# De repente alguém remove um elementousers.pop(0)result = update_balance(users, 50)  # Funciona, mas a lógica está quebrada

Rust (código seguro)

struct User {    name: String,    balance: i32,}

fn update_balance(users: &mut Vec<User>, amount: i32) {    for user in users.iter_mut() {        user.balance += amount;    }}

fn main() {    let mut users = vec![        User { name: "Alice".to_string(), balance: 100 },        User { name: "Bob".to_string(), balance: 200 },    ];        // O compilador não permitirá alterar o vetor durante a iteração acidentalmente    update_balance(&mut users, 50);        // Tentar usar users após a movimentação resultará em erro de compilação    // let other = users; // ownership moved    // println!("{}