FerrousPath

Hoja de ruta

47 lecciones en cinco niveles. Las marcas indican lo que has dado por completado en este navegador.

0/47
Nivel 1 · Principiante10 lecciones · ~3.7 h

Fundamentos

Instala las herramientas, aprende la sintaxis y conoce la propiedad (ownership): la idea sobre la que descansa todo lo demás.

Al terminar: Puedes escribir programas pequeños y leer los errores del compilador sin entrar en pánico.

  1. ✓1.1Primeros pasosPara qué sirve Rust, cómo instalarlo y tu primer programa construido con Cargo.15 min
  2. ✓1.2Variables y tiposEnlaces, mutabilidad, sombreado y los tipos escalares y compuestos con los que se construye cualquier programa.20 min
  3. ✓1.3Funciones y control de flujoExpresiones frente a sentencias, funciones, if, bucles y por qué casi todo en Rust produce un valor.20 min
  4. ✓1.4Propiedad (ownership)Las tres reglas que permiten a Rust liberar memoria sin recolector de basura, y por qué un valor movido no puede volver a usarse.25 min
  5. ✓1.5Referencias y préstamosUsar un valor sin ser su dueño — referencias compartidas y mutables, la regla del aliasing y los slices.25 min
  6. ✓1.6Structs y métodosDefinir tus propios tipos de datos, añadirles comportamiento con bloques impl y derivar los traits más comunes.20 min
  7. ✓1.7Enums y coincidencia de patronesTipos que tienen una de varias formas, Option en lugar de null, y match como análisis exhaustivo de casos.25 min
  8. ✓1.8Colecciones y cadenasVec, String y HashMap — las tres colecciones que usarás a diario — y por qué no se puede indexar una cadena.25 min
  9. ✓1.9Manejo de erroresPánicos para los bugs, Result para los fallos que esperas, y el operador de interrogación que hace indolora la propagación.20 min
  10. ✓1.10Módulos, crates y CargoOrganizar el código en módulos, controlar la visibilidad, usar dependencias de crates.io — y un primer proyecto.25 min
Nivel 2 · Intermedio8 lecciones · ~3.8 h

Practicante

Genéricos, traits, lifetimes, iteradores, punteros inteligentes y los hábitos del Rust idiomático.

Al terminar: Puedes diseñar la API de una biblioteca y publicar una herramienta de línea de comandos con pruebas.

  1. ✓2.1GenéricosEscribir el código una sola vez para muchos tipos, cómo la monomorfización hace que no cueste nada en tiempo de ejecución, y los genéricos constantes.20 min
  2. ✓2.2TraitsComportamiento compartido sin herencia — definir, implementar y derivar traits, y los traits estándar que todo programador de Rust conoce.30 min
  3. ✓2.3LifetimesCómo razona el compilador sobre cuánto tiempo siguen siendo válidas las referencias, qué significan las anotaciones y cuándo tienes que escribirlas.30 min
  4. ✓2.4Clausuras e iteradoresFunciones anónimas que capturan su entorno, los tres traits Fn y cadenas de iteradores perezosos que se compilan a bucles ajustados.30 min
  5. ✓2.5Punteros inteligentes y mutabilidad interiorBox, Rc, RefCell, Weak y Cow — reserva en el heap, propiedad compartida y mutación detrás de una referencia compartida.30 min
  6. ✓2.6Manejo de errores en profundidadDiseñar tipos de error, convertir con From, cadenas de errores, y cuándo recurrir a thiserror y anyhow.20 min
  7. ✓2.7Pruebas y documentaciónPruebas unitarias, pruebas de integración, pruebas de documentación, pruebas basadas en propiedades y las herramientas que mantienen sano un código.20 min
  8. ✓2.8Proyecto: una herramienta de búsqueda para la línea de comandosReúne todo el nivel 2 — construye un pequeño grep con un núcleo en forma de biblioteca, manejo de errores limpio, pruebas y un diseño de API idiomático.45 min
Nivel 3 · Avanzado11 lecciones · ~5.4 h

Sistemas

Hilos, async, macros, unsafe, FFI, WebAssembly, sistemas embebidos y trabajo de rendimiento.

Al terminar: Puedes construir servicios concurrentes y cruzar la frontera hacia C, el navegador y el hardware sin sistema operativo.

  1. ✓3.1Hilos y estado compartidoConcurrencia sin miedo — lanzar hilos, Send y Sync, canales, Mutex, RwLock e hilos con ámbito.30 min
  2. ✓3.2Async y awaitLos futuros como máquinas de estados, ejecutores, tareas, cancelación y cómo escribir E/S concurrente con Tokio.35 min
  3. ✓3.3Trait objects y despacho dinámicodyn Trait, vtables y punteros gordos, la compatibilidad con dyn, y cómo elegir entre despacho estático y dinámico.25 min
  4. ✓3.4Traits avanzadosTipos asociados frente a genéricos, tipos asociados genéricos, restricciones de rango superior, coherencia, traits sellados y traits de extensión.30 min
  5. ✓3.5Macros declarativasmacro_rules! — coincidencia de patrones sobre la sintaxis, repetición, higiene, y cuándo una macro es la herramienta adecuada.25 min
  6. ✓3.6Macros proceduralesMacros derive, de atributo y de tipo función — programas de Rust que se ejecutan dentro del compilador y escriben Rust.30 min
  7. ✓3.7Rust unsafeQué desbloquea realmente unsafe, qué es el comportamiento indefinido, los punteros crudos, y cómo envolver lo inseguro en una API segura y correcta.35 min
  8. ✓3.8FFI — hablar con CLlamar a C desde Rust y a Rust desde C, repr(C), cadenas y propiedad a través de la frontera, bindgen y cbindgen.30 min
  9. ✓3.9Ingeniería del rendimientoMide primero — benchmarks, perfiles, reservas de memoria, disposición de los datos, comprobaciones de límites, inlining, SIMD y configuración de la compilación.30 min
  10. ✓3.10WebAssemblyCompilar Rust para el navegador y más allá — memoria lineal, la ABI en bruto que usa el laboratorio de este sitio, wasm-bindgen y WASI.30 min
  11. ✓3.11no_std y Rust embebidoRust sin sistema operativo — core y alloc, manejadores de pánico, registros mapeados en memoria, HAL y async en microcontroladores.25 min
Nivel 4 · Experto9 lecciones · ~5.7 h

Experto

Layout de memoria, varianza, drop check, Pin, atómicos, estructuras lock-free y ejecutores desde cero.

Al terminar: Puedes escribir y auditar abstracciones unsafe que son correctas (sound) para cualquier código seguro que las use.

  1. ✓4.1Layout de memoria y representaciónTamaño, alineación y relleno, nichos, punteros gordos, tipos de tamaño dinámico y de tamaño cero, memoria sin inicializar y los atributos repr.35 min
  2. ✓4.2Subtipado y varianzaLos lifetimes como relación de subtipado, covarianza, contravarianza e invarianza, y por qué &mut T debe ser invariante.30 min
  3. ✓4.3Drop, drop check y PhantomDataEl orden de los destructores, la seguridad ante pánicos y ante fugas, por qué un Drop genérico hace más estricto al borrow checker, y cómo PhantomData expresa la propiedad.30 min
  4. ✓4.4Pin y tipos autorreferencialesPor qué mover rompe las autorreferencias, qué garantiza Pin, Unpin, el pinning estructural, y cómo las máquinas de estados de async dependen de todo ello.35 min
  5. ✓4.5Atómicos y orden de memoriaEl modelo de memoria que hay detrás de Relaxed, Acquire, Release, AcqRel y SeqCst — happens-before, compare-and-swap, y cómo elegir un orden.40 min
  6. ✓4.6Estructuras de datos lock-freeGarantías de progreso, la pila de Treiber, el problema ABA, la recuperación de memoria con épocas y hazard pointers, y la linealizabilidad.40 min
  7. ✓4.7Async por dentro: construye un ejecutorEl contrato de Future, los wakers y RawWaker, un futuro hoja respaldado por un hilo temporizador, y un ejecutor completo de varias tareas en cien líneas.45 min
  8. ✓4.8Programación a nivel de tiposTypestate, tipos fantasma, genéricos constantes, cálculo a nivel de tipos con traits, y cómo hacer que los programas inválidos no compilen.35 min
  9. ✓4.9Proyecto final: implementar VecConstruye un array que crece a partir de memoria en bruto — NonNull, Layout, crecimiento, tipos de tamaño cero, Drop, Deref, IntoIter — y audita su corrección.50 min
Nivel 5 · Doctorado9 lecciones · ~6.8 h

Investigación

Teoría de tipos, formalismos del borrow checker, modelos de aliasing, RustBelt, verificación y problemas abiertos.

Al terminar: Puedes leer los artículos, cuestionar la semántica y contribuir al propio lenguaje.

  1. ✓5.1La teoría de tipos de la propiedadLógicas subestructurales, tipos afines, regiones, y el linaje intelectual de Rust — desde la lógica lineal y Cyclone hasta cálculos formales como Oxide.45 min
  2. ✓5.2El borrow checker por dentro: NLL y PoloniusMIR, vivacidad e inferencia de regiones en los lifetimes no léxicos, los préstamos en dos fases, y la reformulación basada en préstamos conocida como Polonius.45 min
  3. ✓5.3Modelos de aliasing: Stacked Borrows, Tree Borrows y procedenciaQué tiene realmente permitido hacer el código unsafe — semánticas operacionales para las referencias, la procedencia de los punteros, y las optimizaciones que estos modelos existen para justificar.50 min
  4. ✓5.4Resolución de traits y coherenciaLos traits como programación lógica — cláusulas de Horn, búsqueda de demostraciones, coinducción, normalización, el resolutor de nueva generación y los agujeros de corrección conocidos.45 min
  5. ✓5.5Arquitectura del compiladorDel texto fuente al código máquina — las representaciones, el sistema de consultas y la compilación incremental, la monomorfización, los backends, y cómo empezar a contribuir.40 min
  6. ✓5.6RustBelt: demostrar que el código unsafe es correctoCorrección semántica de tipos, lógica de separación e Iris, la lógica de lifetimes, y cómo se verificaron por máquina las abstracciones unsafe de la biblioteca estándar.50 min
  7. ✓5.7Verificación formal de programas en RustDe Miri y el model checking a los verificadores deductivos — Kani, Creusot, Prusti, Verus, Aeneas, Flux — y por qué la propiedad hace a Rust inusualmente verificable.45 min
  8. ✓5.8Memoria débil y teoría de la concurrenciaModelos de memoria formales — consistencia secuencial, TSO, el modelo de C++/Rust, pruebas de fuego (litmus tests), valores surgidos de la nada, linealizabilidad y model checking con loom.45 min
  9. ✓5.9La frontera: problemas abiertos y cómo contribuirQué está sin resolver en el diseño, la semántica y las herramientas de Rust; cómo evoluciona el lenguaje; una lista de lecturas de doctorado; y cómo empezar a investigar.40 min