Rust
Lenguaje compilado que comprueba el uso de la memoria
Qué es
Rust es un lenguaje de programación para el trabajo que tradicionalmente se hace en C y C++, donde el programa gestiona su propia memoria y a menudo se enlaza con software escrito en otros lenguajes. Su compilador genera código máquina nativo antes de la ejecución. La versión 1.0 se anunció el 15 de mayo de 2015 como un lenguaje que combina el control de bajo nivel sobre el rendimiento con garantías de seguridad, sin recolector de basura ni entorno de ejecución, lo que permite que una biblioteca de Rust sustituya a una de C.
La memoria se gestiona mediante la propiedad, un conjunto de reglas que comprueba el compilador. Cada valor tiene un solo propietario a la vez. Cuando el propietario sale de su ámbito, se descarta el valor y se libera su memoria, en un momento fijado al compilar el programa, no cuando un recolector vuelva a examinarla. El código que necesita un valor sin apropiárselo toma prestada una referencia. Las reglas de préstamo permiten, en cualquier momento, una referencia mutable o cualquier número de referencias inmutables, y exigen que todas sean válidas. Un programa que incumple una regla no compila. Las mismas reglas excluyen las carreras de datos: dos hilos que escriben sobre los mismos datos sin sincronización provocan un error de compilación, en lugar de un fallo intermitente.
Rust no tiene excepciones. Una función que puede fallar de una forma prevista devuelve un Result, que contiene un valor o un error. El compilador avisa de forma predeterminada si quien la llama deja el resultado sin usar. En cambio, un defecto del que el programa no puede recuperarse, como leer más allá del final de un array, pasa por la macro panic!.
El análisis estático es conservador: el compilador rechaza algunos programas que habrían funcionado bien, y hay tareas, como controlar hardware o llamar a otro lenguaje, que no puede comprobar en absoluto. Para esos casos existe unsafe, que habilita cinco capacidades adicionales, entre ellas desreferenciar un puntero sin procesar y llamar a una función no segura, lo que de forma predeterminada incluye cualquier función declarada desde C. No desactiva el comprobador de préstamos. Marca las líneas en las que el programador, en lugar del compilador, responde por la seguridad de la memoria, por lo que la seguridad de esas operaciones depende de que el programador respete sus contratos, también en el código seguro que las rodea. El libro de Rust aconseja mantener esos bloques pequeños y envolverlos en una interfaz segura, como se hace con partes de la biblioteca estándar.
Cada seis semanas se publica un compilador nuevo. Los cambios que romperían código existente esperan a una edición, que llega aproximadamente cada tres años. Hay cuatro: 2015, 2018, 2021 y 2024. La más reciente pasó a ser estable el 20 de febrero de 2025 con Rust 1.85.0. Cada paquete indica su edición en Cargo.toml, cada compilador compila todas las ediciones anteriores y los paquetes de distintas ediciones se enlazan entre sí, por lo que cada proyecto avanza cuando lo decide. Cargo, el gestor de dependencias y herramienta de compilación, viene incluido con el lenguaje; rustfmt mantiene el estilo uniforme, y las bibliotecas de terceros llegan como paquetes llamados crates.
Por qué importa
En C y C++, el código que usa un puntero después de liberar su memoria o escribe los mismos datos desde dos hilos compila sin queja y falla después, de forma intermitente y a menudo lejos de la causa. En Rust, esos programas producen errores de compilación. Como las comprobaciones se hacen al compilar, el programa terminado no paga ningún coste por ellas.
Sin recolector de basura ni entorno de ejecución que incorporar, el código Rust puede servir de base a software de otros lenguajes. Cualquier software capaz de llamar a C puede llamar a un núcleo de Rust mediante una interfaz de C, de modo que una implementación bien probada puede atender a clientes en varias plataformas. El libro de Rust enumera herramientas de línea de comandos, servicios web, dispositivos embebidos y partes importantes del navegador Firefox entre sus usos en producción.
El coste se paga por adelantado. Hay que estructurar el código para que el compilador pueda ver que es seguro, lo que a menudo implica decidir quién es dueño de un valor en lugar de pasar referencias libremente. El propio libro reconoce que acostumbrarse a la propiedad lleva tiempo. Cuando el compilador rechaza un programa que no puede verificar, la solución suele ser una estructura distinta, no una forma de eludir la comprobación.
La estabilidad es la otra parte del trato. Desde la versión 1.0, se han descartado en gran medida los cambios incompatibles, por lo que un cambio capaz de romper código antiguo solo llega a través de una edición que el paquete adopta expresamente.
Cómo se aplica en la práctica
En el portafolio, Rust es el núcleo sobre el que se construye un cliente nativo de mensajería para macOS. El núcleo del protocolo, bien probado, está escrito en Rust y expone una interfaz de C. El cliente, con 11.141 líneas de Swift repartidas en 53 archivos, lo enlaza como una biblioteca estática compilada desde una revisión fijada del proyecto de origen. Es importante fijar esa revisión porque la interfaz de C es el contrato: un núcleo que cambia modifica ese contrato sin cambiar una línea de Swift. Todo lo que devuelve esa interfaz lleva una regla de propiedad. Incumplir una produce una fuga de memoria o un cierre inesperado, sin advertencia del compilador de por medio. Por eso, una capa fina de adaptación se hace cargo de cada puntero y cada cadena que cruza el límite, y ninguna capa superior ve un puntero sin procesar.
Enlazar ese núcleo en una aplicación implica distribuir todo aquello de lo que depende. De eso trata una auditoría de licencias de 644 crates de Rust. Cada crate declara su licencia como una expresión. En cada compilación, la auditoría comprueba todas las expresiones del grafo completo de dependencias frente a una lista de licencias permitidas, interpretando OR como una elección entre licencias y AND como la obligación de cumplir ambas. Cualquier expresión que no se ajuste hace fallar la compilación. Como una comprobación que nunca ha fallado parece igual que otra incapaz de fallar, se provocó su fallo dos veces deliberadamente: una reescribiendo la licencia de un crate con un término que la lista rechaza, y otra cambiando la revisión fijada del núcleo sin regenerar la auditoría. Solo lee los metadatos declarados y no constituye asesoramiento jurídico.
Este sitio no tiene código Rust propio. Se encuentra con el lenguaje de forma indirecta, a través de Ruff, que está escrito en Rust y comprueba todos los scripts Python que toca un commit.
Dónde surgen los problemas
La mayoría de los problemas con Rust está en los límites de lo que comprueba el compilador: la aritmética en una compilación optimizada, la frontera con otro lenguaje y el código que llega con una dependencia.
La aritmética da la vuelta en una compilación para distribución. Un contador que durante las pruebas provocaba un pánico por desbordamiento se convierte, sin avisar, en un número pequeño en producción. En las compilaciones de depuración, Rust comprueba si la aritmética de enteros se desborda y provoca un pánico si detecta un desbordamiento. Una compilación con --release omite la comprobación y vuelve al principio del rango, por lo que 256 en un u8 se convierte en 0. El libro considera un error depender de ese comportamiento. Donde un valor pueda desbordarse, elija explícitamente qué debe ocurrir: checked_* devuelve None si hay desbordamiento, saturating_* se detiene en el límite y wrapping_* da la vuelta de forma deliberada.
fn add_stock(on_hand: u8, delivered: u8) -> Option<u8> {
// None when the sum does not fit, in debug and release alike
on_hand.checked_add(delivered)
}Los errores de memoria vuelven en la frontera con C. Un programa cuya parte de Rust compila sin una sola advertencia presenta fugas de memoria o sufre un cierre inesperado dentro de una llamada externa. No es seguro llamar a las funciones declaradas en un bloque extern, porque el otro lenguaje no impone ninguna regla de Rust. Por eso, quién libera cada puntero es una convención que el compilador no puede ver. Asigne a una sola capa de adaptación la responsabilidad sobre cada puntero y cadena que cruza el límite, escriba cada regla de propiedad junto a la llamada y exponga solo una interfaz segura hacia las capas superiores.
Un pánico alcanza C y el proceso aborta. Una función de Rust llamada desde C entra en pánico y, en lugar de devolver un error, se detiene todo el programa. Desde Rust 1.81, publicado el 5 de septiembre de 2024, un pánico que intenta salir de una función declarada con la interfaz normal "C" aborta el proceso. Convierta los fallos en valores de retorno antes de llegar al límite y declare una función con "C-unwind" solo donde el código del otro lado espere que se desenrolle la pila.
Una actualización rutinaria cambia la licencia de toda la compilación. Un cambio de versión tres niveles más abajo incorpora un crate cuya licencia el producto no puede aceptar, y nada en la compilación lo señala. Cada crate declara su propia licencia y las obligaciones se acumulan en todo el grafo. Compruebe la expresión de cada crate frente a una lista de licencias permitidas en cada compilación, haga que cualquier caso no admitido la haga fallar y provoque una vez el fallo de la comprobación para demostrar que se activa.
Lecturas adicionales
- El lenguaje de programación Rust — El libro oficial, desde la instalación hasta la propiedad, la gestión de errores y el código no seguro.
- ¿Qué es la propiedad? — Las tres reglas de propiedad y cómo se libera la memoria sin recolector de basura.
- Rust no seguro — Las cinco capacidades no seguras, los punteros sin procesar y las llamadas a C mediante
extern. - El formato del manifiesto — Los campos
edition,rust-versionylicensedeCargo.toml. - Anuncio de Rust 1.0 — Los objetivos originales y el compromiso de estabilidad que comenzó con 1.0.