¿Cómo convencer a tu jefx de usar Rust?

Erich Córdoba

Twitter: @el_ericho

erich@mastodon.social

¿Y éste quién es?

"Ingeniero de software"
Aún no aprende a programar.
Rusteador de fines de semana.
Busca la forma de adoptar Rust en su trabajo.

¿Porqué deberiamos usar Rust?

Las razones ya explicadas
Cada semana parece haber un nuevo artículo con más razones
¿Sentido común?

Por confiabilidad

Nunca habrá fallas de segmentación.
El código concurrente libre de data-races.

Por seguridad

Un gran número de CVE es por problemas de memoria.
Rust ayuda a mitigar estos problemas

Por un mejor manejo de dependencias

Cargo hace toda la chamba.
Intenten agregar una nueva dependencia en C++ (en un sólo comando).
Mejora la distribución del producto.

Por que vuelve accesible la programación de sistemas

Poca formación en desarrollo a este nivel.
Hacer algo robusto con facilidad.
Bugs de mejor calidad.

¿Cómo comenzamos a usar Rust?

Hay que buscarle un lugar.
Identificar deficiencias.
Elegir a un candidato.

Reimplementemos todo en Rust, ¡deprisa!, antes de que entremos en razón.

...probablemente no es una buena idea.

Identificar deficiencias

Sabemos de qué pie cojean nuestros proyectos.
¿Hay un bajo desempeño en algún componente?
Un programa con demasiados bugs.
¿Código viejo, inmantenible, sin pruebas?

Rust tiene una interfaz de funciones foráneas (FFI)

Es la forma en que Rust puede platicar con otros lenguajes
Rust -> C
C -> Rust
Python -> Rust

Creando un nuevo componente en Rust

Ya hay un código base que todos usan
Está en una librería
Rust puede usar símbolos de esa librería

De Rust a C


extern crate libc;
use libc::size_t;

#[link(name = "snappy")]
extern {
    fn snappy_max_compressed_length(source_length: size_t) -> size_t;
}

fn main() {
    let x = unsafe { snappy_max_compressed_length(100) };
    println!("max compressed length of a 100 byte buffer: {}", x);
}

Fuente

El crate libc


extern crate libc;
use libc::size_t;

Define tipos para interactuar con la librería C estándar
Permite hablar con funciones nativas de C

Ligar con la librería externa


#[link(name = "snappy")]
extern {
    fn snappy_max_compressed_length(source_length: size_t) -> size_t;
}

El bloque "extern" es para cosas que van a estar definidas aquí.
Le decimos que busque esos símbolos en la librería "snappy"

Usar la funcion externa


fn main() {
    let x = unsafe { snappy_max_compressed_length(100) };
    println!("max compressed length of a 100 byte buffer: {}", x);
}

Todas las operaciones externas son "unsafe".

Extendiendo o migrando un componente existente

Embeber código Rust
Crear una librería estática
Hacer que las otras partes del código usen Rust

De C a Rust


#[no_mangle]
pub extern fn hello_rust() {
    println!("Hello, world!");
}


extern void hello_rust();

int main (int argc, char *argv[])
{
    hello_rust();
    return 0;
}

El "no_mangle" es el secreto


#[no_mangle]
pub extern fn hello_rust() {
    println!("Hello, world!");
}

"no_mangle" desactiva el decorado de nombres en símbolos.
La función se declara como pública.

Compilar como librería estática


[lib]
crate-type = ["staticlib"]

Se genera un archivo.a.
Ese archivo puede vivir dentro de un ejecutable

Python y Rust (otro ejemplo)


from ctypes import cdll
lib = cdll.LoadLibrary("target/release/libtest.so")
lib.hello_rust()

El módulo cdll puede abrir una librería hecha en Rust.
Llamar a las funciones definidas ahí.

Entonces, hasta ahora...

Podemos tomar algo y mejorarlo con Rust.
Tener suficientes argumentos técnicos para convencer a tu jefx.

Pero...

convencer a tu jefx es lo más facil.

El otro factor es...

Tus compañerxs de trabajo.

Tus compañerxs