Rust: una alternativa a C

En la amplia gama de lenguajes de programación que existen, hay, al menos, dos grupos: los de bajo nivel y los de alto nivel. Los primeros son eficientes y le dan un mayor control al programador, aunque sacrifican la facilidad de uso (por ejemplo, C y C++); los segundos, en cambio, tienden a tener una sintaxis amigable y una curva de aprendizaje rápida, pero merma su rendimiento y seguridad (Python). Como lenguaje predominante del primer grupo se encuentra C. No obstante, ha surgido hace poco un nuevo competidor: Rust.

Este texto comienza con una introducción a la programación de sistema para entender de qué trata y cuál es su importancia. Luego conoceremos a Rust, un moderno lenguaje de programación que brinda una real alternativa a C. Más tarde, presentaremos varios ejemplos de código que hacen evidentes las ventajas de Rust sobre C, aunque con un costo: dado que es un lenguaje que busca la seguridad, requiere que el programador explicite muchas cuestiones que tienen que ver con la gestión de memoria. Finalizaremos con algunas conclusiones sobre el futuro de Rust.

Programación de sistemas

Hablar de lenguajes de bajo nivel y de alto nivel no es lo más preciso. Podría considerarse anticuado. Sería mejor decir lenguajes de tipado estáticos y de tipado dinámico, en todo caso. Un lenguaje de programación de tipado estático, como C o C++ o el que introduciremos en este artículo: Rust, tienden a ser una mejor alternativa para la programación de sistemas (a saber, desarrollo de sistemas operativos, kernel, software para microcontroladores, compiladores, etcétera. En suma: un software que permite dar soportar a otro software) que uno interpretado, por las siguientes razones:

1. Es más eficiente: el código puede ejecutarse en menos tiempo. Dado que una vez que una variable define su tipo, ésta no cambia en tiempo de ejecución, permitiendo así una mayor optimización –previa a la ejecución– de parte del compilador.
2. Los ejecutables consumen menos recursos (espacio de disco y memoria). Fundamental en hardware que no tienen muchos recursos (por ejemplo, Raspberry Pi).
   

Igualmente, un lenguaje como Python no es una opción seria para la programación de sistema. Esto, en particular, porque su sistema de tipos es dinámico (ejemplo: una variable puede cambiar de valor numérico a una lista de elementos [o viceversa] en tiempo de ejecución) lo que lo hace propenso a errores que, si el programador no es cuidadoso, puede costarle mucho tiempo en detectar (sin contar lo perjudicial para el rendimiento). Y nadie que construya una pieza de software tan importante, ya sea un driver o un sistema operativo, desea eso en sus partes críticas.

Desde hace algunas décadas, el mundo de la programación de bajo nivel ha sido dominado, primero por C y luego por C++. Entre los sistemas destacados de esta clase –escritos en C– encontramos al kernel Linux, el gestor de versiones Git, el sistema operativo UNIX o el software a bordo de los coches autónomos de Tesla. Todos ellos funcionan debajo de otro software, a modo de soporte.

Si revisamos los proyectos exitosos que se han escrito en C, ¿por qué aún hoy surgen competidores?

Introducción a Rust

Rust es un lenguaje de programación con un sistema de tipo estático. Su principal implementación es un compilador –hasta aquí similar a C–. Sin embargo, contiene varias mejoras sobre éste.

A continuación, describo las que considero relevantes (véase la Figura 1).

Nota: Puedes ver las instrucciones de instalación de Rust –según tu sistema operativo– en este enlace. La versión del compilador de Rust ocupada en este artículo es la 1.65.).

Usando Cargo

Cargo es el gestor de proyectos y paquetes de Rust, incluido con la instalación de Rust. A través de éste podemos crear proyectos y añadir o eliminar dependencias de los proyectos que hayamos creado. Así, cada proyecto que iniciemos podría tener distintas versiones de una misma biblioteca sin caer en conflictos.

En la terminal podemos crear un proyecto de esta manera:

Esto generaría un directorio con el nombre del proyecto, un fichero Cargo.toml y una carpeta src dentro.

El fichero Cargo.toml contiene todas las dependencias que tendrá nuestro proyecto. Así, si alguien necesita que reproduzcamos su proyecto en otro computador, tan solo requeriría que nos entregará su fichero Cargo.toml y luego hacer un cargo build para descargar todas las dependencias.

Dentro de la carpeta src encontramos un fichero de “partida” que, al igual que C, se llama main:

Como pudiste notar, la extensión de un fichero de Rust es rs.

Finalmente, para ejecutar el fichero main.rs, se puede hacer con el comando: cargo run.

Si hacemos de nuevo un ls vemos que, después de ejecutar el cargo run, se ha creado una carpeta target y dentro otra carpeta con el modo debug. Ésta contendrá el binario (ejecutable) con el mismo nombre del proyecto.

En el último ejemplo de este artículo se mostrará cómo añadir una dependencia con Cargo.

Ventajas de Rust con respecto a C

Lo mínimo que uno espera en un lenguaje moderno que quiera compararse con otro pasado es, sin duda, que pueda mejorar los aspectos que causan frustración y dolores de cabeza a los programadores del lenguaje previo.

Ejemplo 1. Verificación de los índices de un arreglo

El manejo de memoria en C suele ser uno de los puntos delicados y causante de múltiples errores en programas si no se usa con cuidado.

Un problema clásico en C es la creación de un arreglo e intentar acceder a un índice que no existe.

Caso correcto:

Caso incorrecto: surge cuando intentamos acceder a un índice que no existe (por ejemplo, cambiando el operador “<” a “<=”). El resultado es el siguiente:

El último número es incorrecto porque se intenta acceder al índice 5, pero en C (y Rust), los índices comienzan desde 0. Por tanto, el arreglo numeros_primos tiene hasta el índice 4. Algo aún peor sería esto:

Compilamos y ejecutamos:

Los valores correctos son hasta el índice válido: 4 (valor 13). Luego, los demás son valores extraídos de la pila (stack) que no tiene ningún sentido, provocando un comportamiento indefinido.

Esto sucede porque, tanto en C como en C++, no hay validación de los rangos de los índices en los arreglos. En este punto, el compilador le da la responsabilidad al programador de ser precavido.

En Rust ocurre todo lo contrario: el compilador no tan solo verifica el rango de los índices en un arreglo, sino que da más información sobre ello. Aquí el código equivalente (exitoso) en Rust:

La explicación:

• La palabra clave let indica que esa variable será inmutable, es decir, una vez asignado el valor no puede ser modificado.
• El tamaño de un arreglo (en este caso 5), se puede obtener con la función len.  Más interesante aún es que, si en vez de añadir un tipo usize (número positivo que representa el tamaño del arreglo) lo cambiamos a size: i32, el compilador devolverá un error, pues, la función len solo devuelve un usize. Esto indica mayores restricciones en Rust en pos de cometer menos fallas en tiempo de ejecución.
  

Ahora, el caso interesante es lo que ocurre si intentamos acceder a un índice inválido o inexistente. Primero cambiando la línea del for a: for i in 0..size+10.

En compilador nos indica que el tamaño del arreglo numeros_primos es de 5 y se está intentando acceder al índice 5 y, dado que comienza desde 0, no nos permite compilar.

Mucho mejor, ¿no?

Ejemplo 2. Manejo de estructuras y paso por referencia

Algo de suma importancia en C es el manejo de estructuras (struct) pues es normal pasarlas como argumentos de una función. Es aquí donde pueden surgir problemas.

Supongamos que necesitamos almacenar la información de libros: título, autor y un identificador. En C, usando una estructura, quedaría de la siguiente forma:

Entonces, compilamos y ejecutamos:

La función strcpy copia un valor (segunda argumento) al puntero del primero (atributo de la estructura Libro). Esto puede parecer algo confuso, pero es normal tener este tipo de nombres de funciones en C.

Lo interesante viene ahora: cambiar el valor del título ya asignado. En C, se puede hacer usando la referencia del puntero de una estructura. Primero añadiremos la función:

Vemos que ahora el primer argumento es el puntero a la estructura (símbolo “*”). Luego, debemos pasar la referencia de la estructura:

La versión equivalente en Rust presenta varias cuestiones interesantes que hacen a este lenguaje más seguro que C, aunque con un precio: la sintaxis en algunos casos puede volverse compleja de entender.

Lo primero distinto que se puede notar es el cambio del tipo de dato de titulo y de autor a String, y es que, en C, no existe el tipo String. Rust maneja las secuencia de caracteres con dos tipos: String y str. El primero es una secuencia de caracteres dinámicos que pueden modificarse. En cambio, str es inmutable. Para crear un String se debe usar la función String::from.

Otra cuestión interesante es la palabra reservada mut. Ésta es clave para saber cuándo un valor puede “mutar”, o sea luego de asignar un valor se puede reasignar a otro.

A la función modificarTitulo, justo antes del tipo de dato (Libros), se le debe añadir &mut. ¿Qué significa? Esta referencia (a la estructura) permite modificar sus atributos. Esto en C se puede hacer simplemente con el signo de referencia “&” y con un puntero. En Rust, en cambio, se debe ser explícito, aunque para nosotros es mejor porque con solo ver mut se puede saber que una variable cambiaría su valor.

Esto que puede parecer interesante y dar claridad sobre C. Ahora, si se ejecuta, el título de la estructura primerLibro cambia.

Todo bien. Pero si añadimos esta línea después de la invocación de mostrarLibro…:

…encontramos algo curioso:

Dicho en otras palabras, el valor de la variable primerLibro se movió a un nuevo propietario (la función mostrarLibro). Esto se entiende si vemos la firma de la función: fn mostrarLibro(libro: Libros). Al primer argumento, la variable libro, no se le pasa una referencia, desplazando el valor. Se soluciona pasando por referencia la variable primerLibro (Levick), añadiendo el símbolo de “&” antes del tipo (no es necesario añadir el mut, pues no se va a modificar ningún atributo de la estructura).

El diseño de Rust fue pensado para ser muy seguro con la gestión de memoria. Evita cualquier error en la asignación de recursos de una variable en tiempo de ejecución. Por ello, es más estricto en la fase de compilación estática, aunque podría volverse bastante intrincado si no se tiene claro ciertos principios.

Ejemplo 3. Propiedad y movimiento de variables

Rust mejora el manejo de memoria si lo comparamos con C (como lo vimos en los ejemplos anteriores) e incluso el mismo compilador nos entrega más información. No obstante, este manejo de memoria podría volverse –en algunos casos– enrevesado. Véase este ejemplo:

Este código crea una estructura Persona con el identificador 659440. La asigna a la variable persona (en la Figura 2 se puede apreciar cómo sería el estado de la pila). Luego, crea una nueva variable, otra_persona, que le asigna (mueve) el valor de persona y, finalmente, se muestra en pantalla la variable otra_persona y persona.

La macro superior: “#[derive(Debug)]” permite mostrar por pantalla una struct usando un print. De otra forma, se tendría que implementar una forma manual de mostrar cada atributo de Persona.

Sin embargo, al intentar compilar devuelve el siguiente error:

Lo que dice es que al intentar mostrar los valores de la variable persona (último println) ésta se ha movido a otro lugar (cambio de propietario). Y claro, se movió cuando se asignó a la variable otra_persona (véase la Figura 3 para entender qué ocurre con la pila.). Para evitar estos casos, es conveniente activar la copia de la estructura (Klabnik & Nichols; Rust Ownership, Move and Borrow - Part 1).

Lo primero es añadir Copy y Clone en la macro de Persona:

Luego, el problema se resuelve:

Resultado:

Para copiar de manera segura una estructura se requiere añadir el Copy y Clone. La diferencia entre ambas radica en que hay tipos de datos que pueden ser copiados de manera implícita (como el ejemplo anterior), por lo que no es necesario invocar a la función clone:

Sin embargo, si la estructura Persona tuviera un atributo que no soportará la copia implícita (por ejemplo, String), entonces se requiere invocar a la función clone de manera explícita (implementarla manualmente).

Un ejemplo: implementar manualmente la función clone. Entonces, lo primero sería quitar Copy y Clone de la macro (pues lo implementaremos):

Comprender cómo funciona la memoria en Rust es, acaso, el mayor reto del lenguaje. Pero aunque pueda parecer duro a ratos, al final presenta una manera más efectiva y segura de escribir código de sistemas. Queda a tu criterio saber si el esfuerzo vale la pena.

Ejemplo 4. Añadiendo dependencias con Cargo

Incorporar nuevas bibliotecas a un proyecto de Rust es simple. Otro ejemplo: añadir la biblioteca rand para generar números aleatorios. Dentro del fichero Cargo.toml, y debajo de [dependencias], añade lo siguiente:

Ahora crea un fichero con este ejemplo:

Luego, ejecuta el comando:

Se comenzará a descargar la biblioteca rand según la versión asignada. Nada más queda ejecutar el cargo run.

Conclusión

Rust es seguro y eficiente. En este artículo mostramos cuáles son las ventajas de Rust con respecto a C, transformándolo en una buena alternativa para sistemas donde se desea evitar fallos en la gestión de memoria al contar con un sistema más restrictivo a la hora de manejar el tiempo de vida de las variables. Esto hace que muchos problemas se detecten en la fase de compilación y no en ejecución (como suele ocurrir en C y C++).

No obstante, Rust no es fácil de aprender si lo comparamos con Python (u otro lenguaje de tipado dinámico). Su sintaxis requiere ser explícita para evitar errores. Aunque tenga ventajas sobre C, es un lenguaje que requiere su tiempo para comprenderlo, sobre todo si no has estado expuesto con anterioridad a la gestión manual de memoria.

El futuro de Rust parece prometedor. En diciembre de 2022 –cuando se escribió este artículo–, Rust aparece en la posición 20 de TOEBI (el ranking más popular para medir el impacto de un lenguaje de programación en la industria).

Con todo hay que ser cautelosos. La cantidad de código, o sea, sistemas escritos en C y C++ es enorme y, por más que un lenguaje presente características superiores, la adopción de una herramienta pasa más por otros factores: una robusta comunidad y que empresas importantes lo comiencen a usar (validación).

Recomendaciones de lecturas

Recomiendo hojear –y si lo lees, aún mejor– el libro The Rust Programming Language (Klabnik & Nichols, 2018), para obtener un mayor conocimiento del lenguaje.

Código

Todo el código presentado en este artículo se encuentra en el siguiente repositorio.

Referencias

• Klabnik, S., & Nichols, C. (2018). The Rust Programming Language. https://lise-henry.github.io/books/trpl2.pdf
• Levick, R. ·. (2018). Rust: Pass-By-Value or Pass-By-Reference? https://blog.ryanlevick.com/rust-pass-value-or-reference/
• Rust Ownership, Move and Borrow - Part 1. (2021). Rust Community. https://www.openmymind.net/Rust-Ownership-Move-and-Borrow-part-1/