¿Por qué Rust?

Rust es un lenguaje de programación de sistemas de alto nivel con abstracciones sin costo. Aprende qué problemas resuelve, cómo los resuelve, y quién lo está usando.

Transcript

1. ¿POR QUÉ RUST?
2. DECISIONES
3. CONTROL
 FLEXIBILIDAD
 VIOLACION DE ACCESO
 CONDICION DE CARRERA
4. CONTROL
 FLEXIBILIDAD
 VIOLACION DE ACCESO
 CONDICION DE CARRERA
5. CONTROL
 FLEXIBILIDAD
 VIOLACION DE ACCESO
 CONDICION DE CARRERA
6. CONTROL
 FLEXIBILIDAD
 VIOLACION DE ACCESO
 CONDICION DE CARRERA
7. char *bloque = (char *) malloc(5 * sizeof(char));
8. char *bloque = (char *) malloc(5 * sizeof(char));
9. char *bloque = (char *) malloc(5 * sizeof(char)); ¡REGRESALA!
10. free(bloque);
11. fn es_espacio_en_blanco(texto: &str) -> bool { texto.chars() .all(|c| c.is_whitespace()) }
12. fn cargar_imagenes(fuentes: &[PathBuf]) -> Vec<Image> { fuentes.iter() .map(|fuente| Image::load(fuente)) .collect() }
13. ABSTRACCIONES SIN COSTO.
14. ¿ QUÉ ES RUST ?
15. PROGRAMACION DE SISTEMAS.
16. DESARROLLADO POR MOZILLA.
17. MULTIPARADIGMA.
18. FUERTE TIPADO ESTATICO.
19. CONTROL
 SEGURIDAD 
 VELOCIDAD
20. ¿ QUIÉNES USAN RUST ?
23. INTEROPERABILIDAD
24. void Focos_Crear(uint16_t *); void Focos_PrenderTodos(void); void Focos_Prender(int); void Focos_Apagar(int); HABLEMOS CON C
25. TEST(Focos, PrenderVariosFocos) { Focos_Prender(9); Focos_Prender(8); TEST_ASSERT_EQUAL_HEX16(0x180, focos); }
26. extern crate libc; extern { fn Focos_Crear(focos: &mut libc::c_ushort); fn Focos_PrenderTodos(); fn Focos_Prender(para_foco: libc::c_int); fn Focos_Apagar(para_foco: libc::c_int); }
27. fn main() { let mut focos = 0u16; unsafe { Focos_Crear(&mut focos); Focos_Prender(9); Focos_Prender(8); } println!(“Prendido {}", 0x180); println!("Focos: {}", focos); }
28. focos $ cargo run Finished dev [unoptimized + debuginfo] target(s) in 0.26s Running `target/debug/focos` Prendido 384 Focos: 384
29. CODIGO DE ALTO NIVEL. ALTO RENDIMIENTO DE BAJO NIVEL.
30. Revisemos un método implementado en Ruby On Rails con puro Ruby, como una extensión nativa en C y en Rust.
31. class String def en_blanco? /\A[[:space:]]*\z/ == self end end RUBY
32. static VALUE rb_str_blank_as(VALUE str) { rb_encoding *enc; char *s, *e; enc = STR_ENC_GET(str); s = RSTRING_PTR(str); if (!s || RSTRING_LEN(str) == 0) return e = RSTRING_END(str); while (s < e) { int n; C
33. case 0x2029: case 0x202f: case 0x205f: case 0x3000: #if ruby_version_before_2_2() case 0x180e: #endif /* found */ break; default: return Qfalse; C
34. extern “C” fn fast_blank(buf: Buf) -> bool { buf.as_slice().chars().all(|c| c.is_whitespace()) } RUST
36. CASOS DE USO.
37. BAJO NIVEL sistemas operativos, servidores, exploradores. 
 WebAssembly
 Web APIs
 Redes
 Blockchain
 IoT
 JUEGOS
 MACHINE LEARNING
38. Miremos un poco más las abstracciones sin costo.
39. CODIGO DE ALTO NIVEL. tipos de datos algrabraicos, genéricos, traits, clausuras, funciones de orden superior, macros higienicos, pruebas incorporadas. código rápido, bajo consumo de memoria, no runtime, sin costos ( no hay recolector de basura, etc ) RENDIMIENTO DE BAJO NIVEL.
40. enum Evento { Carga, TeclaPresionada(char), Click { x: i64, y: i64 } } fn imprimir_evento(evento: Evento) { match evento { Evento::Carga => println!("Cargado"), Evento::TeclaPresionada(c) => println!("Tecla {} presionada", c), Evento::Click {x, y} => println!("Clicked en x={}, y={}", x, y), } }
41. SEGURIDAD DE MEMORIA SIN RECOLECTOR DE BASURA.
42. SIN VIOLACION DE ACCESO.
 SIN INVALIDACION DE ITERADORES.
 SIN PUNTEROS COLGADOS.
 SIN DOUBLE FREE.
 SIN COMPORTAMIENTO INDEFINIDO.
 SIN PUNTEROS NULOS.
 SIN CONDICIONES DE CARRERA.

43. GARANTIZADAS CUANDO COMPILAS.
44. SEGURIDAD DE MEMORIA.
45. SEGURIDAD DE MEMORIA.
46. MANEJO DE MEMORIA EN RUST.
47. OWNERSHIP.
48. @androbtech