El dilema de los lenguajes de sistemas

Durante medio siglo, programar sistemas fue una elección forzada entre dos males. O tomabas el control absoluto de la memoria con C y C++ y aceptabas que un solo descuido corrompiera el proceso, o delegabas ese control a un recolector de basura con Java o Go y renunciabas a decidir cuándo y dónde vive cada byte. No existía una tercera puerta. Rust es esa tercera puerta, y para entender por qué importa hay que sentir primero el peso del dilema.

Un solo compromiso, dos bandos

Todo lenguaje de sistemas responde a una pregunta antes que a ninguna otra: ¿quién gestiona la memoria? La respuesta te asigna un bando, y cada bando cobra su precio.

flowchart LR
P[Programa de sistemas] --> Q[Quien gestiona la memoria]
Q -->|el programador| C[C y C++: control total pero memoria insegura]
Q -->|un runtime con GC| G[Java y Go: seguros pero con recolector]
Q -->|el compilador| R[Rust: control total y seguro sin GC]
style C fill:#f38ba8,color:#11111b
style G fill:#fab387,color:#11111b
style R fill:#a6e3a1,color:#11111b

Durante décadas la fila de abajo parecía imposible: se daba por hecho que control y seguridad eran magnitudes inversas. Rust demuestra que la disyuntiva era falsa, pero solo se aprecia su logro tras ver qué duele en cada bando.

El precio del control: C y C++

En C y C++ tú decides cada asignación y cada liberación. Ese poder es real, pero el lenguaje no te protege de ti mismo. Dos clases de bug han costado décadas de vulnerabilidades:

#include <string.h>

char *saludo(void) {
    char buf[8];                 // 8 bytes en la pila
    strcpy(buf, "hola, mundo");  // 12 bytes copiados: desbordamiento de buffer
    return buf;                  // devolvemos un puntero a memoria local...
}                                // ...que deja de existir aqui: puntero colgante

Este fragmento contiene dos de los fallos más explotados de la historia:

• Desbordamiento de buffer: strcpy escribe 12 bytes en un arreglo de 8, pisando la pila. Así funcionan innumerables exploits de ejecución remota de código.
• Puntero colgante (use-after-free): buf vive en la pila de saludo; al retornar, esa memoria se reutiliza, y quien lea el puntero devuelto obtendrá basura o datos de otro.

Lo aterrador no es que el código falle, sino que puede que no falle: compila sin errores, quizá funciona en tus pruebas, y revienta en producción con datos reales. C te da un cuchillo sin mango. C++ moderno añade unique_ptr, vector y RAII para mitigarlo, pero nada en el lenguaje impide volver a coger el cuchillo por el filo.

El precio de la seguridad: Java y Go

La otra familia resolvió el problema quitándote el volante. Java, Go, C# y compañía introducen un recolector de basura (GC): un subsistema que rastrea qué memoria sigue viva y libera el resto automáticamente. El puntero colgante desaparece, porque nada se libera mientras alguien lo use.

// Go: imposible tener un puntero colgante. El GC vela por la memoria.
func procesar(datos []byte) []byte {
    salida := make([]byte, len(datos)) // reservado en el heap gestionado
    copy(salida, datos)
    return salida                      // el GC liberara esto cuando nadie lo use
}

El precio se paga en otro sitio, y es doble:

• Pausas impredecibles: el GC debe, cada cierto tiempo, recorrer el grafo de objetos vivos. Aunque los recolectores modernos son concurrentes y sus pausas de “parar el mundo” bajan del milisegundo, siguen introduciendo latencia en la cola (tail latency) justo cuando más tráfico hay. Para un juego a 120 fps, un motor de trading o un marcapasos, ese jitter es inaceptable.
• Sin control fino: no decides cuándo se libera la memoria ni cómo se dispone en caché. Pagas un sobrecoste de espacio (el heap gestionado suele necesitar de 2 a 5 veces la memoria del dato vivo) y renuncias a la localidad de caché que exige el alto rendimiento.

El hueco que nadie llenaba

Pon las dos columnas frente a frente y el dilema queda desnudo:

Rust rechaza la premisa de que haya que elegir. El mismo saludo que en C era una bomba, en Rust ni siquiera llega a ejecutarse:

// El equivalente Rust del saludo() de C. NO COMPILA, y esa es la victoria.
fn saludo() -> &str {
    let buf = String::from("hola, mundo");
    &buf
}
// error[E0106]: missing lifetime specifier
// error[E0515]: cannot return reference to local variable `buf`
//   el valor `buf` se libera al final de la funcion

El compilador detecta, antes de generar un solo byte de máquina, que estás devolviendo una referencia a memoria que va a morir. No hay GC vigilando en ejecución: la garantía se demostró en compilación y desaparece del binario final. La versión correcta es igual de directa y no cuesta nada en tiempo de ejecución:

fn saludo() -> String {
    String::from("hola, mundo") // se MUEVE al llamador: sin copia, sin dangling, sin GC
}