Después de las dos entregas anteriores (C/C++ y C#, y Java/JavaScript) de este análisis de los lenguajes de programación más en boga, en esta ocasión centraré ni nuevo post en el análisis del lenguaje Rust de reciente aparición.

Rust es un lenguaje que si bien lleva entre nosotros desde hace ya casi una década, se podría decir que no ha sido hasta hace bien poco que ha empezado a tener mayor presencia en el panorama mundial de los lenguajes de desarrollo. Fue diseñado alrededor de 2010 dentro de la organización de Mozilla Research por lo que su proyecto siempre ha tenido características de «Open Source». La palabra «Rust» para los no angloparlantes viene a significar algo así como «metal oxidado« lo cual no es una buena idea desde el punto de vista de marketing para usar como nombre de algo innovador y moderno.

Desde su diseño se quiso que Rust contribuyese a solucionar algunos de los grandes contratiempos en el desarrollo de sistemas software: el desarrollo «seguro» de software en grandes sistemas y que además tuviesen necesidades de programación concurrente. Esto que se dice muy fácil, supone intentar dotar al lenguaje de mecanismos y construcciones que ayuden a solventar cuestiones como el manejo y asignación de memoria, la gestión concurrente de hilos de ejecución y posibles agujeros de seguridad como «buffer overrun» o accesos no autorizados a posiciones de memoria. Y encima, todo esto al mismo tiempo que se proporcionase un rendimiento de ejecución similar al de los lenguajes compilados.

Entre las características principales del lenguaje Rust estarían:

• Sintaxis derivada mayoritariamente de C++ (curly bracket y con construcciones semánticas y «keywords» importadas de dicho lenguaje
• Curiosamente soluciona los problemas de asignación de memoria sin recurrir a mecanismos como «garbage collectors» sino que utiliza un concepto de «propiedad» que, si bien cuesta asimilar al principio, siguiendo unos pequeños escenarios se entiende muy bien. Además el compilador ayuda a no cometer errores y detecta usos incorrectos de este mecanismo de propiedad en tiempo de compilación.
• Es un lenguaje orientado a objetos pero con un polimorfismo distinto al que estamos acostumbrados, de hecho el concepto se denomina «ad-hoc polymorphism» y utiliza el concepto de «traits» para imponer restricciones o tratos a los tipos de variables permitidas en cada situación. También soporta encapsulación
• Soporte para «generics», «enums» y «structs» (aunque estos últimos son más parecidos a los «structs» de C++ que a los de C)
• Un manejo curioso (cuando menos) de manejo de patrones («pattern matching») con una keyword específica «match» que se parece más a un «switch» con esteroides.
• Manejo de errores avanzado pero utilizando un mecanismo que se parece más a las «promises» de ECMA Script 6 que al típico manejo de excepciones y «try/catch»
• Utilización de módulos para empaquetar, distribuir y compartir código binario.
• Construcciones para dar soporte a la programación funcional: iteradores y closures

Os dejo aquí un par de snippets de código para que podáis haceros una idea de qué aspecto tiene el código fuente en Rust

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

extern crate rand;
use std::io;
use std::cmp::Ordering;
use rand::Rng;
 
fn main() {
   println!("Guess the number!");
   let secret_number = rand::thread_rng().gen_range(1, 101);
   loop {
      println!("Please input your guess.");
      let mut guess = String::new();
      io::stdin().read_line(&mut guess)
       .expect("Failed to read line");
      let guess: u32 = match guess.trim().parse() {
        Ok(num) => num,
        Err(_) => continue,
      };
      println!("You guessed: {}", guess);
      match guess.cmp(&secret_number) {
         Ordering::Less => println!("Too small!"),
         Ordering::Greater => println!("Too big!"),
         Ordering::Equal => {
            println!("You win!");
            break;
         }
      }
   }
}

Personalmente no tengo una amplia experiencia en programar con Rust como pueda tenerla en otros lenguajes como Java o C# pero diría que Rust es un lenguaje interesante y diferente sin llegar a caer en lenguajes más raros o complejos de reciente aparición también. Me han resultado curiosos los mecanismos de propiedad (ownership) encaminados a solventar el manejo seguro de memoria y me ha sorprendido también el rendimiento (bastante aceptable) de los ejecutables que resultan al compilar este tipo de programas o aplicaciones.

También es curiosos como una aparentemente inocente keyword como «match» puede ser en realidad tan potente y ayudar a simplificar estructuras que en otros lenguajes provocarían código más difícil de leer o comprender.

En su lado negativo diría que Rust es un lenguaje que a primera vista «engaña». Al principio puede parecer sencillo de entender y empezar a utilizar, pero conforme vas aprendiendo o intentando utilizar construcciones más avanzadas la forma que tiene el lenguaje de abordarlas es realmente diferente y provoca cierto desconcierto. Por ejemplo, el concepto de la «propiedad» o los «traits» tienden a confundir a programadores que vengan de otros lenguajes más «tradicionales». Mi consejo, si os decidís a empezar a programar con Rust, es que os leáis con detenimiento primero algún buen libro sobre el lenguaje como por ejemplo «The Rust Programming Language» de Steve Klabnik y Carol Nichols

En resumen, Rust es un lenguaje de programación interesante y novedoso con un diseño que rompe con las formas tradicionales y que está cada vez mas en boga, si bien es cierto que actualmente ocupa el puesto número 34 en el índice TIOBE lo cual dice algo sobre su nivel de adopción. Por otro lado, todos los años de 2015 a 2019 a sido nominado como el «lenguaje de programación más querido» en la encuesta anual que se realiza en Stack Overflow lo cual nos dice hasta que punto es atractivo para la comunidad de desarrolladores.

En una siguiente entrega, cubriré el análisis de otro lenguaje con bastante popularidad como es Go.