Empezando con RUST

Habiendo expuestos las razones por las cuales considero que hoy es el momento de estudiar Rust y algunos conceptos generales de programación, ya es momento de atacar “la biblia de Rust”, setear el entorno y escribir el primer programa.
Sí, todo en un mismo artículo.

Conocido en la comunidad “Rustacean” como el libro, sin dudas, punto de partida ineludible.

¿Cuáles son mis herramientas para comenzar este aprendizaje? Una MacBook Pro, late 2012, a la que agregué un SSD de 512gb y dos memorias RAM de 8gb cada una, por lo tanto macOS será mi sistema operativo. Visual Studio Code será el editor de código que me acompañará, como lo hace desde que empecé en este mundo.

Instalando Rust

El primer paso, simple pero fundamental.
En la terminal, yo utilizo la nativa del sistema, escribimos la siguiente línea:

curl — proto ‘=https’ — tlsv1.2 https://sh.rustup.rs -sSf | sh

Si le diste “enter” la terminal estará instalando la última versión de Rust y de haber sido una ejecución correcta verás el siguiente mensaje

En caso de haberte encontrado con algún inconveniente, podés dirigirte al canal de #beginners dentro del Discord oficial, al foro oficial de Rust o, como siempre, a Stack Overflow.

Una vez instalado Rust, es necesario contar con un “linker”, que vendría a ser un programa que une todo los archivos de salida que generemos en uno solo. Este “linker” es un compilador de C, necesario para nuestra aventura, ya que algunos paquetes de Rust dependen del código de este lenguaje.
En tu terminal podrás instalarlo, si es que aún no lo tienes, con la siguiente línea:

xcode-select --install

No es una mala costumbre, actualizar la versión de Rust que tenemos en nuestro equipo y lo podrás hacer escribiendo en la terminal:

rustup update

En caso de tener problemas, puedes desinstalar Rust tipeando:

rustup self uninstall

Y ahora sí, para cerrar la sección instalación dejando todo en orden tras nuestro paso, tipeando la siguiente línea de código

rustc --version

Deberías recibir como respuesta, la versión de Rust instalada, el commit hash y la fecha de commit.

En caso de que desearas checkear la documentación del lenguaje, en tu terminal escribís <rustup doc> “enter” y voilà, a entretenerse.

Ahora sí, estamos listos para escribir el primer programa de Rust.

Primer programa en Rust

Para empezar con este camino vamos a escribir un programa, súper simple que imprima la frase “Hello Rust!”.
Entiendo que si estás leyendo estas líneas, conocés como crear carpetas y archivos desde la terminal, pero no está de más pasar un pequeño “copy paste” de como lo hice yo

cd Desktop
mkdir rust_learning
cd rust_learning
mkdir hello_rust
cd hello_rust
touch main.rs

Primeras notas a tomar. Una buena práctica es usar la notación con “_” para separar palabras en los nombres de los archivos y estos tendrán la terminación “.rs”.
Ahora abrimos “mains.rs” en el editor de código y para lograr nuestro objetivo tipeamos

fn main() {
    println!("Hello Rust!");
}

Perfecto, tenemos nuestro programa listo, para imprimir “Hello Rust!” solo falta ir a la terminal y escribir

rustc main.rs
./main

Y ahora tu terminal debería mostrarte lo siguiente

De haberlo logrado, felicitaciones, primer programa de Rust terminado con éxito. Pero, en lugar de dormir en los laureles, analicemos un poco qué es lo que estuvo pasando acá.

Analizando “Hello Rust!” program

Luego de crear la carpeta contenedora y el archivo “main.rs”, pasamos directamente a la acción y escribimos

fn main() {
}

La función “main” es la primer función que el compilador de Rust va a ejecutar cada vez que lo invoquemos. Fácilmente podemos ver que de querer pasarle parámetros, debemos hacerlo dentro de los paréntesis, y que el cuerpo de la función estará contenido dentro de los “{}”.
Ahora el cuerpo de la función

println!("Hello Rust!");

A simple vista “println!” parece una función pero el “!” nos dice que se trata de un macro. En Rust usamos macros para definir funciones con un número de argumentos variables, algo así como una función pero más potente. A este macro le pasamos el parámetro que deseamos imprimir entre “ ” y cerramos la línea con un “;”.
Nuestro primer programa, fue simple y su explicación también. Pero, ¿qué hicimos posteriormente en la terminal para ejecutarlo?

Un proceso de dos pasos -> compilación + ejecución.
Primero invocamos al compilador indicándole cuál era el archivo que deseábamos compilar

rustc main.rs

Una vez que le dimos “enter” en la carpeta que contiene “main.rs” apareció otro archivo llamado “main”. Este es el resultado de compilar nuestro programa y se trata de un archivo generado en código binario, para que nuestra computadora pueda entenderlo y posteriormente ejecutarlo.
La orden de ejecución, la dimos aquí

./main

Y así es como llegamos a ver “Hello Rust!” impreso en nuestra terminal.

Nuestro primer proyecto con Cargo

En mi artículo anterior hice una breve mención sobre este gestor de paquetes, constructor de sistemas y administrador de dependencias.
Si bien, en un programa tan simple como el anterior no es necesario recurrir a Cargo, un primer contacto con este gestor, es extremadamente necesario.

Entonces, vayamos por nuestro primer programa con Cargo.

Pasos previos

Por primera y única vez, únicamente para checkear que todo está listo, en la terminal escribiremos

cargo --version

Si Cargo se instaló correctamente, allá cuando instalamos Rust, obtendrás como respuesta algo de este estilo

Creando un proyecto con Cargo

Ahora sí, todo listo para empezar a familiarizarnos con quién será nuestro compañero, esperemos, durante un largo tiempo. Cuando queremos escribir un nuevo programa en Rust, Cargo se encarga de “setear” el ambiente y se ocupa de ciertos pasos que harán que nuestra experiencia sea mucho más amigable y simple.
Entonces, creemos un nuevo proyecto con Cargo.
En la terminal, situado en la carpeta “rust_learning”, deberás ingresar lo siguiente

cargo new hello_cargo

Y deberías recibir esta respuesta de tu terminal

Veamos que encontramos en la carpeta “hello_cargo”, que el gestor ha creado y lo hará, con el nombre que le indiquemos, siempre que creemos un nuevo proyecto.
Primero vemos la carpeta “src”, dónde se encuentra “main.rs” creado automáticamente, un archivo .gitignore, ya que cargo automáticamente crea un repositorio de Git y otro archivo llamado “Cargo.lock”.

En este archivo, vivirán todas las dependencias o librerías externas que utilicemos. Por defecto, Rust incluye en cada proyecto la conocida librería Standard que brinda las herramientas mínimas para poder llevar a adelante un proyecto. Como nos encontramos creando un programa extremadamente simple, no agregaremos librerías pero de hacerlo, las encontraríamos en este archivo debajo de “[dependencies]”.
“Cargo.lock” debería verse así ahora mismo

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]

Nombre del archivo, su versión y el año de edición.

Pero volvamos a nuestro proyecto, que vivirá dentro de la carpeta “src”, y en este caso, estará escrito en el archivo “main.rs” quién en este momento se ve así

fn main() {
    println!("Hello, world!");
}

Es evidente que esta función creada automáticamente por Cargo precisa una sola modificación, la palabra “world” debe ser reemplazada por “Rust” y nuestro programa está listo. Pero, ¿cómo hacemos para ejecutarlo?

Vayamos por partes, analizando aquello que Cargo nos brinda.
Lo primero que podemos hacer en nuestra terminal es lo siguiente

cd hello_cargo
cargo build

Tras un “enter” la respuesta debería haber sido

Cargo se encargó de compilar nuestro código. Encontraremos una nueva carpeta, llamada “target” y dentro de ella una carpeta llamada “debug” es allí dónde el archivo binario ejecutable por nuestra computadora se encuentra alojado. Ahora bien podríamos ejecutar este archivo introduciendo la dirección del mismo, pero Cargo nos ofrece un atajo

cargo run

Esta simple línea en nuestra terminal, indicará a Cargo que debe, primero compilar el código, solo en caso de no haber sido compilado antes o de haber sufrido alguna modificación, y consecuentemente ejecutar el archivo binario. De haber seguido este paso, la respuesta debería ser

Nuestro primer proyecto con Cargo exitoso, está listo.

Una última observación. Quizás no será necesario para un programa de esta sencillez, pero existe el siguiente comando

cargo check

Con esta línea, indicaremos a Cargo que debe chequear si el código que estamos escribiendo compila de manera correcta. En un proyecto de gran magnitud, será conveniente realizar esta acción para detectar posibles errores sin cargar a nuestro procesador con la creación de un archivo ejecutable mediante “cargo build” o crear este archivo y ejecutarlo con “cargo run”.

Llegamos al final de la tercer entrega de mi camino aprendiendo Rust. Aprendimos a instalar Rust, actualizarlo y a crear un programa sumamente sencillo, compilarlo y ejecutarlo. Posteriormente dimos los primeros pasos con nuestro futuro mejor amigo, Cargo.
En la próxima entrega revisaré ciertos conceptos generales de programación y su aplicación y alcances dentro del entorno de Rust.