Rust es un lenguaje de programación de sistemas diseñado para resolver los problemas más persistentes de la informática: la gestión insegura de la memoria y los errores de concurrencia. Su origen se remonta a 2006, cuando Graydon Hoare, un desarrollador de Mozilla, buscó una alternativa a C++ para evitar errores críticos como los segfaults (errores de segmentación), los cuales pueden causar fallos catastróficos en aplicaciones como navegadores web o sistemas operativos.

A diferencia de lenguajes como Java o Python, Rust no utiliza un Garbage Collector (recolector de basura) para limpiar la memoria automáticamente mientras el programa corre. En su lugar, emplea un sistema de “propiedad” (ownership) que garantiza la seguridad de la memoria en tiempo de compilación. Esto permite que Rust ofrezca un rendimiento comparable al de C y C++, pero sin los riesgos de acceder a memoria que ya no es válida o que ha sido liberada por otro proceso.

El lenguaje se fundamenta en tres pilares fundamentales:
1. Seguridad de memoria sin GC: Evita errores comunes de punteros sin el costo de ejecución de un recolector de basura.
2. Concurrencia sin “data races”: Gracias a su sistema de tipos, permite programar en paralelo de forma segura (fearless concurrency), evitando que dos partes del código intenten modificar el mismo dato al mismo tiempo.
3. Abstracciones de coste cero: Puedes usar estructuras de alto nivel sin perder la velocidad y eficiencia del hardware.

Cuando se intenta realizar una operación insegura, como intentar usar una variable que ya ha sido liberada de la memoria, el compilador de Rust simplemente se niega a compilar el programa. Esto obliga al programador a corregir el error antes de que el software llegue al usuario, eliminando una de las fuentes de errores más costosas en la ingeniería de software. Debido a esta robustez, Rust ha sido adoptado en el kernel de Linux, Windows, Android y ChromeOS.

fn main() {
    // Creamos una variable de tipo String que almacena datos en el "heap" (montículo)
    let mensaje_original = String::from("Hola, Rust!");

    // Transferimos la propiedad (ownership) de la variable a 'mensaje_copiado'
    // A partir de este punto, 'mensaje_original' ya no es válida para el compilador.
    let mensaje_copiado = mensaje_original;

    // Accedemos al contenido de la variable que ahora posee la memoria
    println!("El mensaje es: {}", mensaje_copiado);

    // Si intentáramos usar 'mensaje_original' aquí, el compilador daría un error de compilación.
    // Esto evita errores de "use-after-free" (uso después de liberar memoria).
}

En el código anterior, la función main sirve como el punto de entrada del programa. Primero, declaramos la variable mensaje_original de tipo String; este tipo de dato reserva memoria dinámica en el heap. En la línea donde asignamos let mensaje_copiado = mensaje_original;, ocurre el concepto central de Rust: el move (movimiento). La propiedad de la memoria se transfiere de mensaje_original a mensaje_copiado. Como resultado, mensaje_original deja de existir para el compilador, evitando que el programa intente acceder a una dirección de memoria que ahora pertenece a mensaje_copiado. Finalmente, la macro println! utiliza mensaje_copiado para imprimir el texto. Al terminar la función, Rust libera la memoria automáticamente de forma segura porque sabe exactamente que mensaje_copiado es la última dueña de esos datos.

N° 1