Ownership, traits, lifetimes, async (edición 2024), unsafe/FFI, no_std, embebido, debugging y programación a nivel de tipos.
Cada nivel construye sobre el anterior. Sin saltos, sin huecos.
La visión aérea: qué hace único a Rust, sus pilares (ownership, traits, seguridad) y el mapa mental del camino.
Seguridad de memoria garantizada en compilación sin recolector de basura, y la mentalidad que exige.
Instalar la toolchain, cargo, y la edición 2024 (Polonius, async closures).
Inmutabilidad por defecto, shadowing, tipos escalares y la inferencia de Rust.
if como expresión, los bucles, y la primera mirada a match.
Structs, impl, métodos, y la diferencia con las clases de otros lenguajes.
Enums con datos, match exhaustivo, if let, y modelar estados imposibles de romper.
Los tipos que eliminan el null y las excepciones: valores que pueden faltar o fallar, explícitos.
El corazón de Rust: cada valor tiene un dueño, y mover transfiere la propiedad. Sin copias ni GC.
Prestar en vez de mover: referencias compartidas (&) y mutables (&mut), y la regla del prestador.
Cómo Rust demuestra que una referencia nunca sobrevive a lo que apunta. Anotaciones de lifetime.
El modelo de cadenas de Rust, los slices, y por qué hay dos tipos de string.
Los errores clásicos del borrow checker, NLL, Polonius, y cómo reestructurar en vez de pelear.
Los traits definen capacidades (como interfaces), con implementaciones por defecto. La abstracción de Rust.
Funciones y tipos genéricos con bounds de trait, monomorfización y abstracción de coste cero.
dyn Trait, dispatch estático vs dinámico, y cuándo usar cada uno.
Los traits derivables que todo tipo usa, PartialEq/Eq/Ord/Hash, y qué significa cada uno.
Sobrecargar operadores, Deref coercion, y Drop (el destructor determinista de Rust).
Tipos asociados, Generic Associated Types, y cómo expresan relaciones ricas entre tipos.
Las colecciones de la librería estándar, cuándo usar cada una y su rendimiento.
El trait Iterator, la evaluación perezosa, y map/filter/fold: transformar sin bucles.
Las funciones anónimas que capturan su entorno, sus tres traits, y move closures.
Adaptadores (zip, chain, flat_map), collect, y escribir tu propio iterador.
El operador ?, propagar errores, y cuándo panic vs Result.
Diseñar tipos de error, el trait Error, y las crates thiserror (librerías) y anyhow (apps).
Punteros con semántica propia: Box (heap), Rc (contado), Arc (contado y thread-safe).
Mutar a través de una referencia compartida de forma controlada, y el borrow checking en runtime.
Lifetime bounds, elisión, HRTB, y los patrones que confunden al borrow checker.
Por qué Rust prohíbe mover ciertos valores, Pin, y la base de los futures async.
Crear hilos, mover datos entre ellos, y por qué Rust hace imposibles las data races.
Los dos traits marcadores que el compilador usa para garantizar concurrencia segura.
Compartir datos entre hilos con Arc<Mutex>, y comunicar con canales (paso de mensajes).
La sintaxis async/await, qué es una función async, y por qué Rust no trae runtime.
El trait Future, el modelo poll/wake, y cómo una función async es una máquina de estados.
El runtime async de facto: el scheduler work-stealing, el I/O driver, tasks y spawn.
Streams, select!, join!, la cancelación por drop, y las async closures de la edición 2024.
Observar y depurar código async: tokio-console, tracing, y los deadlocks async.
Qué desbloquea unsafe, por qué existe, y la responsabilidad que implica.
Raw pointers, dereferenciarlos, y las cinco cosas que solo unsafe permite.
Llamar C desde Rust y Rust desde C, extern, bindgen, y la ABI.
El patrón clave: encapsular unsafe tras una API segura cuyas invariantes garantizas tú.
El atributo #![no_std], el crate core, y programar sin sistema operativo.
Rust en microcontroladores: embedded-hal, PACs, RTIC y Embassy (async embebido).
GlobalAlloc, allocators a medida, y la gestión de memoria de bajo nivel.
Generar código con macro_rules!: patrones, repetición, y la higiene de macros.
Macros que manipulan el AST: derive, attribute y function-like, con syn y quote.
Typestate, phantom types, y usar el sistema de tipos para prevenir errores en compilación.
Workspaces, features condicionales, perfiles de build, y el ecosistema de crates.
Los tests integrados, doc tests, y el testing basado en propiedades (proptest).
Las abstracciones de coste cero, perfilar (samply), SIMD, y optimización guiada por datos.
Publicar un crate, documentar, semver, y las herramientas del ecosistema.
Cómo funciona el compilador de Rust (HIR, MIR, borrow checker), y hacia dónde va el lenguaje.
El sistema que garantiza seguridad de memoria sin recolector de basura.
Abstracción sin coste, el sistema de tipos más expresivo de los lenguajes de sistemas.
Cómo el borrow checker demuestra que tus referencias son válidas.
async/await, futures, tokio y las async closures del edición 2024.
Cuando necesitas bajar al metal: unsafe, punteros crudos e interop con C.
Rust sin librería estándar: embebido, allocators y el kernel.
Las herramientas para depurar y optimizar Rust en producción.
Macros y programación a nivel de tipos: el nivel PhD de Rust.
Empieza por los fundamentos y sube nivel a nivel hasta el dominio total.
Comenzar el camino →