Introducción a Rust

Erich Córdoba
Twitter: @ericho
erich@mastodon.social

Presentación: http://github.com/ericho/rust-intro.git

¿Qué es Rust?

Rust es un lenguaje de programación de sistemas extremadamente rápido, previene fallas de segmentación y garantiza la seguridad de los hilos de ejecución.
https://www.rust-lang.org/es-ES/

Lenguaje de programación de sistemas

  • Lenguaje utilizado para crear sistemas.
  • Software que provee servicios a otros programas
  • Sistemas operativos, motores de juegos, automatización industrial, etc
  • C, C++, Swift, D, Go

Extremádamente rápido

  • Lenguaje compilado
  • No necesita recolector de basura
  • Abstracciones sin costo
  • Competitivo con C/C++ (incluso mejor en algunos casos)

Previene fallas de segmentación

  • No hay fallas de segmentación
  • No hay punteros nulos
  • No hay punteros inválidos

Seguridad de los hilos de ejecución

  • Previene condiciones de carrera de datos (data-races)
  • Sólo puede haber un dueño de los datos al mismo tiempo

¡Hola mundo!


fn main() {
    println!("¡Hola mundo!");
}

¡Hola compilador!


fn main() {
    let s = String::from("¡Hola mundo!");
    let a = s;
    println!("{}", a);
    println!("{}", b);
}
                    

error[E0382]: use of moved value: `s`
 --> foo.rs:5:20
     |
     3 |     let a = s;
     |         - value moved here
     4 |     println!("{}", a);
     5 |     println!("{}", s);
     |                    ^ value used here after move

Propiedad y préstamo

Ownership and borrowing

  • Es la base del manejo de memoria
  • Cada valor tiene exáctamente un dueño
  • Las variables se mueven a nuevas localidades, previniendo que las anteriores las usen
  • Lo que tienes, lo puedes prestar

Propiedad y préstamo


fn main() {
    let s = String::from("¡Hola mundo!");
    let a = &s;
    println!("{}", a);
    println!("{}", b);
}
Pruébalo

¡Hola compilador! (v2)


fn main() {
    let s = 5;
    s = s + 1;
    println!("{}", s);
}
                    

error[E0384]: re-assignment of immutable variable `s`
 --> foo.rs:3:5
  |
  2 |     let s = 5;
  |         - first assignment to `s`
  3 |     s = s + 1;
  |     ^^^^^^^^^ re-assignment of immutable variable

Variables inmutables por defecto

  • Cualquier variable (o binding) es inmutable.
  • Si queremos que cambie en el futuro hay que marcarlo explícitamente.

Variables inmutables por defecto


fn main() {
    let mut s = 5;
    s = s + 1;
    println!("{}", s);
}

Propiedad y préstamo de valores mutables


fn add_one(x: &mut i32) {
    *x = *x + 1
}

fn main() {
    let mut s = 5;
    add_one(&mut s);
    println!("{}", s);
}
Pruébalo

Operaciones inseguras

  • Rust no deja hacer cosas malas si se lo pedimos.
  • El compilador ignorará una sección de código si está marcada como "unsafe"
  • Útil para hablar con componentes hecho en otros lenguajes.

Usando unsafe


fn main() {
    let raw_p: *const u32 = &10;

    unsafe {
        assert!(*raw_p == 10);
    }
}

El paradigma de Rust

  • Es un lenguaje multiparadigma
  • Hay elementos de POO, programación funcional, estructurada, etc
  • Se dice que Rust tiene su propio paradigma

Lo mio es la POO, ¿Rust me sirve?

  • Puedes hacer casi todo lo mismo que con POO
  • Puede ser diferente a lo que estás acostumbrad@
  • Tienes datos y comportamiento, encapsulamiento, herencia, entre otros.

Una estructura y métodos


pub struct AveragedCollection {
    list: Vec<i32>,
    average: f64,
}

impl AveragedCollection {
    pub fn add(&mut self, value: i32) {
        self.list.push(value);
        self.update_average();
    }
    pub fn average(&self) -> f64 {
        self.average
    }

    fn update_average(&mut self) {
        let total: i32 = self.list.iter().sum();
        self.average = total as f64 / self.list.len() as f64;
    }
}

La interfaz de funciones foráneas (FFI)

  • ¡Paren todo, vamos a rehacerlo en Rust! <- Probablemente una mala idea
  • Rust puede platicar con otros lenguajes.
  • Si tu lenguaje habla con C, puede hablar con Rust
  • Ejemplo, arreglar el desempeño de Python con Rust

Portando código a Rust incrementálmente

  • Tengo un viejo programa en C que quiero pasar a Rust
  • Usa la FFI
  • Refactoriza, pasa tu función a Rust y recompila.
Rust out your C

¿Hay librerías en Rust?

¿Por qué debería aprender Rust?

  • Pinta a ser el futuro en la programación de sistemas (y en otras muchas áreas)
  • Te hace un mejor desarrollador
  • Lenguaje más querido en la encuesta de stackoverflow de los dos últimos años
  • Conocer como es un lenguaje moderno. (no es un lenguaje hipster, hipster es usar lo mismo de hace 15 años)

No me dedico a programar sistemas

¿De qué me sirve Rust?

  • Rust acerca la programación de sistemas a cualquier desarrollador.
  • Te obliga a pensar diferente
  • "¿Hasta dónde vivirá este cacho de memoria?"

¿Quién usa Rust?

La comunidad de Rust

  • Es una comunidad amigable y abierta
  • Se nota que aman hacer esto
  • Siempre dispuestos a ayudar y orientarte

Proyectos interesantes

  • Redox: Un sistema operativo hecho en Rust
  • Rocket: Un web framework
  • Diesel: Un ORM y generador de consultas

Recursos

¡Gracias!