Saltar al contenido
wandres.dev
Iniciar sesión

Rust

Ownership, traits, lifetimes, async (edición 2024), unsafe/FFI, no_std, embebido, debugging y programación a nivel de tipos.

52 unidades · 257 temasEmpezar la ruta
  1. 00

    Nivel 0

    1 temas
    1. 01La ontología de Rusthechoen curso
  2. 01

    Nivel 1

    5 temas
    1. 01El dilema de los lenguajes de sistemashechoen curso
    2. 02La promesa de Rusthechoen curso
    3. 03El compilador como aliadohechoen curso
    4. 04Dónde brilla Rust en 2026hechoen curso
    5. 05La curva de aprendizajehechoen curso
  3. 02

    Nivel 2

    5 temas
    1. 01Instalar Rust con rustuphechoen curso
    2. 02cargo, el gestor todo-en-unohechoen curso
    3. 03Tu primer programa y la anatomía de un cratehechoen curso
    4. 04La edición 2024 de Rusthechoen curso
    5. 05El tooling diario: rustfmt, clippy y rust-analyzerhechoen curso
  4. 03

    Nivel 3

    6 temas
    1. 01let y la inmutabilidad por defectohechoen curso
    2. 02Los tipos escalares y el desbordamientohechoen curso
    3. 03Inferencia de tipos, anotaciones y sufijoshechoen curso
    4. 04Shadowing frente a mutabilidad, y las constanteshechoen curso
    5. 05Tipos compuestos primitivos: tuplas y arrayshechoen curso
    6. 06Funciones: recibir un valor y devolver un resultadohechoen curso
  5. 04

    Nivel 4

    5 temas
    1. 01if como expresiónhechoen curso
    2. 02Los bucles: loop, while y forhechoen curso
    3. 03match: el pattern matchinghechoen curso
    4. 04if let y while lethechoen curso
    5. 05Bloques, el tipo unit y el tipo neverhechoen curso
  6. 05

    Nivel 5

    5 temas
    1. 01Definir structs: campos, tuplas y unidadeshechoen curso
    2. 02impl y métodos: &self, &mut self y selfhechoen curso
    3. 03Funciones asociadas y constructores: Self y newhechoen curso
    4. 04Derivar traits: Debug, Clone y el formato de depuraciónhechoen curso
    5. 05Organización: módulos, visibilidad y el proyectohechoen curso
  7. 06

    Nivel 6

    5 temas
    1. 01Enums con y sin datos: la unión etiquetada segurahechoen curso
    2. 02match exhaustivo: extraer datos y blindar el futurohechoen curso
    3. 03Los patrones a fondo: binding, guardas, rangos y desestructuraciónhechoen curso
    4. 04Modelar el dominio con enums: estados inválidos irrepresentableshechoen curso
    5. 05Enums frente a la herencia: una cosa u otra sin claseshechoen curso
  8. 07

    Nivel 7

    5 temas
    1. 01Option: la ausencia de valor sin nullhechoen curso
    2. 02Desenvolver Option con seguridad: de match a los métodoshechoen curso
    3. 03Result: el error como valor, no como excepciónhechoen curso
    4. 04Los combinadores: transformar sin desenvolver a manohechoen curso
    5. 05El operador ?: propagar errores con limpiezahechoen curso
  9. 08

    Nivel 8

    5 temas
    1. 01Ownership: dueño, préstamo y movimientohechoen curso
    2. 02Move semantics: la propiedad se muevehechoen curso
    3. 03Copy vs Move: cuándo se copia y cuándo se muevehechoen curso
    4. 04Drop y la liberación deterministahechoen curso
    5. 05Ownership y funciones: mover, devolver y el porqué del borrowinghechoen curso
  10. 09

    Nivel 9

    5 temas
    1. 01Prestar en vez de mover: la referencia compartida &Thechoen curso
    2. 02Referencias mutables &mut T: modificar sin poseerhechoen curso
    3. 03Las reglas del borrow checker: alias O mutaciónhechoen curso
    4. 04Referencias colgantes: el dato nunca muere antes que su referenciahechoen curso
    5. 05Borrowing en la práctica: &self, &mut self y préstamos parcialeshechoen curso
  11. 10

    Nivel 10

    5 temas
    1. 01Por qué existen los lifetimes: nombrar la región donde una referencia valehechoen curso
    2. 02Anotar lifetimes en funciones: atar la salida a la entradahechoen curso
    3. 03Lifetimes en structs: cuando un tipo guarda una referencia prestadahechoen curso
    4. 04Elisión de lifetimes: las tres reglas que te ahorran escribirloshechoen curso
    5. 05'static y los patrones de lifetimes del día a díahechoen curso
  12. 11

    Nivel 11

    5 temas
    1. 01String frente a str: el dueño y la vistahechoen curso
    2. 02Slices: referencias con longitud a una porciónhechoen curso
    3. 03Texto UTF-8: chars, bytes y por qué no se indexahechoen curso
    4. 04Convertir y parsear texto: de y hacia Stringhechoen curso
    5. 05Los tropiezos clásicos con stringshechoen curso
  13. 12

    Nivel 12

    5 temas
    1. 01Los tres errores clásicos: qué te dice el borrow checker de verdadhechoen curso
    2. 02NLL: un préstamo muere en su último uso, no al cerrar la llavehechoen curso
    3. 03Polonius: el borrow checker de nueva generaciónhechoen curso
    4. 04Reestructurar en vez de pelear: split borrows, índices, funciones y scopeshechoen curso
    5. 05clone con criterio: cuándo copiar es la respuesta y cuándo es un síntomahechoen curso
  14. 13

    Nivel 13

    5 temas
    1. 01Definir e implementar un trait: capacidades, no jerarquíashechoen curso
    2. 02Implementaciones por defecto: métodos requeridos y provistoshechoen curso
    3. 03Traits como parámetros: impl Trait, bounds y valores de retornohechoen curso
    4. 04Bounds múltiples y la cláusula where: firmas legibleshechoen curso
    5. 05Coherencia y la regla del huérfano: el patrón newtypehechoen curso
  15. 14

    Nivel 14

    5 temas
    1. 01Funciones genéricas: parametrizar el código sobre el tipohechoen curso
    2. 02Structs y enums genéricos: contenedores para cualquier tipohechoen curso
    3. 03Métodos genéricos e impl condicionales: la API que el tipo se ganahechoen curso
    4. 04Monomorfización: la abstracción de coste cerohechoen curso
    5. 05Bounds múltiples, where y la síntesis: traits más genéricoshechoen curso
  16. 15

    Nivel 15

    5 temas
    1. 01Dispatch estático frente a dinámico: el compromiso fundamentalhechoen curso
    2. 02dyn Trait por dentro: el puntero gordo y la vtablehechoen curso
    3. 03Object safety: qué traits pueden ser trait objectshechoen curso
    4. 04Box de dyn Trait y colecciones heterogéneashechoen curso
    5. 05Estático o dinámico: cuándo elegir cada dispatchhechoen curso
  17. 16

    Nivel 16

    5 temas
    1. 01Debug y Display: imprimir para el programador y para el usuariohechoen curso
    2. 02Clone y Copy: la copia profunda y la duplicación de bitshechoen curso
    3. 03Igualdad y orden: por qué el float solo es PartialOrdhechoen curso
    4. 04Hash y Default: claves de mapa y valores por defectohechoen curso
    5. 05From, Into, TryFrom: las conversiones idiomáticashechoen curso
  18. 17

    Nivel 17

    5 temas
    1. 01Sobrecarga de operadores: cada símbolo es un traithechoen curso
    2. 02Deref y la coerción: por qué una ref a String vale donde se pide ref a strhechoen curso
    3. 03Drop: el destructor determinista y por qué no puedes llamarlohechoen curso
    4. 04DerefMut y la transparencia de Box, Rc y compañíahechoen curso
    5. 05AsRef, Borrow y las conversiones ligeras: cuándo cada unahechoen curso
  19. 18

    Nivel 18

    5 temas
    1. 01Tipos asociados: cuando el tipo de salida pertenece al traithechoen curso
    2. 02Asociados frente a genéricos: uno-a-uno o muchos-a-unohechoen curso
    3. 03GATs: tipos asociados que a su vez son genéricoshechoen curso
    4. 04Lifetimes asociados y el patrón type Item de ahechoen curso
    5. 05GATs en la práctica: colecciones que prestan y async en traitshechoen curso
  20. 19

    Nivel 19

    5 temas
    1. 01Vec a fondo: longitud, capacidad y crecimiento amortizadohechoen curso
    2. 02HashMap: la API, el patrón entry y por qué exige Hash y Eqhechoen curso
    3. 03BTreeMap y BTreeSet: mapas ordenados y consultas por rangohechoen curso
    4. 04VecDeque, HashSet y BinaryHeap: y cómo elegir la colección correctahechoen curso
    5. 05Rendimiento y layout: por qué Vec es cache-friendly y el coste real de cada operaciónhechoen curso
  21. 20

    Nivel 20

    5 temas
    1. 01El trait Iterator y next: producir valores uno a unohechoen curso
    2. 02La pereza: nada ocurre hasta que se consumehechoen curso
    3. 03Adaptadores fundamentales: map, filter, fold, sum y ziphechoen curso
    4. 04Los consumidores: collect, for, count, find, any y allhechoen curso
    5. 05IntoIterator: iter, iter_mut, into_iter y cómo for los usahechoen curso
  22. 21

    Nivel 21

    5 temas
    1. 01Qué es un closure: una función que recuerda su entornohechoen curso
    2. 02FnOnce, FnMut y Fn: los tres traits del closurehechoen curso
    3. 03Closures move: forzar la captura por valorhechoen curso
    4. 04Closures como parámetros y retornos: impl Fn, dyn Fn y Boxhechoen curso
    5. 05Closures e iteradores: el estilo funcional de Rusthechoen curso
  23. 22

    Nivel 22

    5 temas
    1. 01Adaptadores potentes: componer flujos de datoshechoen curso
    2. 02collect polimórfico: Vec, String, HashMap y el turbofishhechoen curso
    3. 03Iteradores falibles: collect a Result y el corto-circuitohechoen curso
    4. 04Escribe tu propio iterador: impl Iterator con nexthechoen curso
    5. 05Cadenas de iteradores: por qué son de coste cerohechoen curso
  24. 23

    Nivel 23

    5 temas
    1. 01panic!: el fallo irrecuperable y su maquinariahechoen curso
    2. 02Result a fondo: el fallo como valor y el fin de las excepcioneshechoen curso
    3. 03El operador ?: propagación, desazucarado y conversión con Fromhechoen curso
    4. 04? más allá de Result: Option, main y closureshechoen curso
    5. 05unwrap y expect: el panic explícito y sus alternativas segurashechoen curso
  25. 24

    Nivel 24

    5 temas
    1. 01El trait Error: la firma de un tipo que dice ser un fallohechoen curso
    2. 02Tu propio enum de error, y Box dyn Error para lo heterogéneohechoen curso
    3. 03thiserror: el boilerplate de errores, derivadohechoen curso
    4. 04anyhow: un solo tipo de error, con contexto, para aplicacioneshechoen curso
    5. 05From, ? y la estrategia: tipado en librerías, opaco en binarioshechoen curso
  26. 25

    Nivel 25

    5 temas
    1. 01Box de T: el valor que vive en el heaphechoen curso
    2. 02Rc de T: propiedad compartida por conteo de referenciashechoen curso
    3. 03Arc de T: compartir entre hilos con conteo atómicohechoen curso
    4. 04Weak de T: referencias débiles para romper cicloshechoen curso
    5. 05Elegir el puntero: Box, Rc, Arc y cómo combinarloshechoen curso
  27. 26

    Nivel 26

    5 temas
    1. 01El problema: mutar a través de una referencia compartidahechoen curso
    2. 02`Cell<T>`: mutar moviendo valores, sin prestar referenciashechoen curso
    3. 03`RefCell<T>`: el borrow checker mudado a tiempo de ejecuciónhechoen curso
    4. 04`Rc<RefCell<T>>` y `Arc<Mutex<T>>`: estado compartido y mutablehechoen curso
    5. 05`UnsafeCell<T>`: la primitiva sobre la que todo se construyehechoen curso
  28. 27

    Nivel 27

    5 temas
    1. 01Cotas de lifetime: `T: 'a` (outlives) y `'a: 'b` (subtipado)hechoen curso
    2. 02Elision avanzada: donde el compilador se rinde y te obliga a anotarhechoen curso
    3. 03HRTB: `for<'a>`, o cuantificar sobre todos los lifetimeshechoen curso
    4. 04Lifetimes en trait objects: `dyn Trait + 'a` y el `'static` implicitohechoen curso
    5. 05Casos dificiles: estructuras autorreferenciales, temporales y como resolverloshechoen curso
  29. 28

    Nivel 28

    5 temas
    1. 01El problema: mover es copiar bytes, y eso invalida los punteros internoshechoen curso
    2. 02Structs auto-referenciales: imposibles de nombrar, y por qué async los fabricahechoen curso
    3. 03`Pin<P>`: el contrato de inmovilidad, garantizado por el sistema de tiposhechoen curso
    4. 04`Unpin`: el permiso para moverse, y por qué casi todo lo tienehechoen curso
    5. 05Pin en la práctica: `Future::poll`, `pin!` y `Box::pin`hechoen curso
  30. 29

    Nivel 29

    5 temas
    1. 01thread::spawn y JoinHandle: lanzar un hilo y cosechar su valorhechoen curso
    2. 02move y 'static: por qué el hilo debe poseer lo que tocahechoen curso
    3. 03Compartir datos mutables entre hilos: por qué el compilador lo bloqueahechoen curso
    4. 04Scoped threads: prestar de la pila del padre sin miedohechoen curso
    5. 05Fearless concurrency: qué garantiza Rust y por qué es revolucionariohechoen curso
  31. 30

    Nivel 30

    5 temas
    1. 01Send y Sync: los dos marcadores de la concurrenciahechoen curso
    2. 02Send: mover un valor a otro hilohechoen curso
    3. 03Sync: compartir una referencia entre hiloshechoen curso
    4. 04La tabla clave: Rc, Arc, RefCell y Mutexhechoen curso
    5. 05Auto-traits y unsafe impl: la responsabilidad del marcadorhechoen curso
  32. 31

    Nivel 31

    5 temas
    1. 01Mutex: exclusión mutua con la cerradura pegada al datohechoen curso
    2. 02Arc y Mutex: el patrón canónico del estado mutable compartidohechoen curso
    3. 03RwLock: muchos lectores o un solo escritorhechoen curso
    4. 04Canales mpsc: comparte memoria comunicandohechoen curso
    5. 05Deadlocks: Rust previene carreras de datos, no interbloqueoshechoen curso
  33. 32

    Nivel 32

    5 temas
    1. 01Qué es async: concurrencia masiva de E/S sin un hilo por tareahechoen curso
    2. 02async fn y .await: la sintaxis de una función perezosahechoen curso
    3. 03Por qué Rust no trae runtime: async es del lenguaje, ejecutarlo nohechoen curso
    4. 04El modelo mental: una async fn es una máquina de estadoshechoen curso
    5. 05Tu primer programa async con Tokiohechoen curso
  34. 33

    Nivel 33

    5 temas
    1. 01El trait Future: un cálculo que aún no ha terminadohechoen curso
    2. 02poll: Ready con el valor o Pending con un todavía nohechoen curso
    3. 03El Waker: cómo un future dormido pide que lo despiertenhechoen curso
    4. 04La máquina de estados: async fn compilada a un enum que hace pollhechoen curso
    5. 05Escribir un Future a mano: poll sin magia, con un temporizadorhechoen curso
  35. 34

    Nivel 34

    5 temas
    1. 01Anatomía de un runtime: scheduler, driver de E/S y timerhechoen curso
    2. 02El runtime por dentro: tokio::main, multihilo y construcción manualhechoen curso
    3. 03Tareas y robo de trabajo: por qué el scheduler escalahechoen curso
    4. 04E/S async con Tokio: un servidor echo concurrentehechoen curso
    5. 05tokio::sync, spawn_blocking y el Mutex que no cruza un awaithechoen curso
  36. 35

    Nivel 35

    5 temas
    1. 01join! y try_join!: avanzar varios futures a la vezhechoen curso
    2. 02select!: reaccionar al primero que terminehechoen curso
    3. 03Streams: iteradores asincronoshechoen curso
    4. 04Cancelacion: cancelar es dropear el futurehechoen curso
    5. 05async closures y los pecados clasicos del runtimehechoen curso
  37. 36

    Nivel 36

    5 temas
    1. 01Por qué depurar async es difícil: la pila miente y la tarea no está ahíhechoen curso
    2. 02tracing: instrumentación estructurada que sí sigue a la tareahechoen curso
    3. 03tokio-console: ver en vivo la población de tareas del runtimehechoen curso
    4. 04Deadlocks y stalls async: cuando el await no vuelvehechoen curso
    5. 05Profiling async: el poll time, la contención y las herramientashechoen curso
  38. 37

    Nivel 37

    5 temas
    1. 01Qué es unsafe y por qué existehechoen curso
    2. 02Los cinco superpoderes que solo unsafe desbloqueahechoen curso
    3. 03unsafe no apaga el borrow checkerhechoen curso
    4. 04Invariantes y la responsabilidad del bloque unsafehechoen curso
    5. 05Cuándo usar unsafe, cuándo no, y Mirihechoen curso
  39. 38

    Nivel 38

    5 temas
    1. 01*const T y *mut T: los punteros sin promesashechoen curso
    2. 02Crear y dereferenciar: de la referencia al puntero y de vueltahechoen curso
    3. 03Aritmética de punteros: offset, add, wrapping y la procedenciahechoen curso
    4. 04Conversiones y NonNull: referencias, punteros y direccioneshechoen curso
    5. 05Los peligros: UB, y por qué Vec se construye sobre punteros crudoshechoen curso
  40. 39

    Nivel 39

    5 temas
    1. 01Llamar a C desde Rust: declarar extern C, enlazar y por qué es unsafehechoen curso
    2. 02Tipos compatibles con C: repr(C), los escalares de core::ffi y las cadenashechoen curso
    3. 03Llamar a Rust desde C: exportar con no_mangle y extern Chechoen curso
    4. 04Generar bindings: bindgen y cbindgen en vez de declarar a manohechoen curso
    5. 05Memoria y cadenas en la frontera: quién libera qué y el terminador nulohechoen curso
  41. 40

    Nivel 40

    5 temas
    1. 01El patrón central: un núcleo unsafe tras una API 100% segurahechoen curso
    2. 02Mantener las invariantes: el contrato que hace correcto al unsafehechoen curso
    3. 03Un wrapper seguro sobre una API C: imposible de usar malhechoen curso
    4. 04Newtype y typestate: estados inválidos que ni se pueden escribirhechoen curso
    5. 05Documentar la seguridad: # Safety, // SAFETY y la cultura del kernelhechoen curso
  42. 41

    Nivel 41

    5 temas
    1. 01no_std: enlazar contra core en vez de stdhechoen curso
    2. 02no_std: qué pierdes y qué conservashechoen curso
    3. 03El crate alloc: recuperar Vec, Box y String sin stdhechoen curso
    4. 04no_std: el panic_handler y el punto de entradahechoen curso
    5. 05Los mundos de no_std: un mismo core, muchos destinoshechoen curso
  43. 42

    Nivel 42

    5 temas
    1. 01Por qué Rust en el embebido: seguridad sin red debajohechoen curso
    2. 02La pila embebida: del registro crudo al driver portablehechoen curso
    3. 03Un programa bare-metal: no_std, no_main y el LED que parpadeahechoen curso
    4. 04RTIC: concurrencia por interrupciones con garantías en compilaciónhechoen curso
    5. 05Embassy: async/await en el metal, sin heap y sin RTOShechoen curso
  44. 43

    Nivel 43

    5 temas
    1. 01El trait GlobalAlloc y el atributo global_allocatorhechoen curso
    2. 02Escribir un allocator global que instrumenta y cuenta asignacioneshechoen curso
    3. 03La Allocator API: elegir el asignador por estructura de datoshechoen curso
    4. 04Arenas y bump allocators: reservar mucho, liberar de golpehechoen curso
    5. 05no_std y alloc: recuperar Box y Vec aportando tu propio allocatorhechoen curso
  45. 44

    Nivel 44

    5 temas
    1. 01macro_rules!: metaprogramación por ejemplohechoen curso
    2. 02Especificadores de fragmento: expr, ident, ty, tt, pat, blockhechoen curso
    3. 03Repetición: generar código para listas variádicashechoen curso
    4. 04Higiene: por qué las macros de Rust no filtran variableshechoen curso
    5. 05Casos reales: reimplementar vec!, un mini-DSL y cuándo usar macroshechoen curso
  46. 45

    Nivel 45

    5 temas
    1. 01Macros procedurales: código que se ejecuta en el compiladorhechoen curso
    2. 02syn y quote: parsear los tokens, generar el códigohechoen curso
    3. 03Un derive macro paso a paso: generar un getter por campohechoen curso
    4. 04Attribute macros: reescribir un item enterohechoen curso
    5. 05El coste de una proc-macro y cuándo vale la penahechoen curso
  47. 46

    Nivel 46

    5 temas
    1. 01El sistema de tipos como lenguaje: estados inválidos que no compilanhechoen curso
    2. 02PhantomData: llevar información de tipo sin ocupar memoriahechoen curso
    3. 03Typestate: el estado de un objeto vive en su tipohechoen curso
    4. 04Const generics: tipos parametrizados por valoreshechoen curso
    5. 05Sealed traits y los límites de la programación a nivel de tiposhechoen curso
  48. 47

    Nivel 47

    5 temas
    1. 01Cargo.toml, dependencias y SEMVERhechoen curso
    2. 02Workspaces: monorepos que comparten lockfilehechoen curso
    3. 03Features: compilación condicional y unificaciónhechoen curso
    4. 04Perfiles de build: dev, release y el ajuste finohechoen curso
    5. 05Cargo extendido: build.rs, install y subcomandoshechoen curso
  49. 48

    Nivel 48

    5 temas
    1. 01Tests unitarios: la prueba que vive junto al códigohechoen curso
    2. 02Tests de integración: probar el crate desde fuerahechoen curso
    3. 03Doc tests: la documentación que se compila y no mientehechoen curso
    4. 04Property testing y fuzzing: miles de entradas contra tus invarianteshechoen curso
    5. 05Mocking, cobertura y CI: la disciplina del proyecto seriohechoen curso
  50. 49

    Nivel 49

    5 temas
    1. 01Abstracciones de coste cero: la promesa y cómo leerla en el ensambladorhechoen curso
    2. 02Perfilar: samply, flamegraphs y benchmarks estadísticos con criterionhechoen curso
    3. 03SIMD: autovectorización, std::simd portable y cuándo bajar a los intrinsicshechoen curso
    4. 04Optimizaciones idiomáticas: menos asignaciones, mejor layout, cero clones de máshechoen curso
    5. 05Los mitos del rendimiento: por qué el idiomático es rápido y la regla del 3 %hechoen curso
  51. 50

    Nivel 50

    5 temas
    1. 01Publicar un crate en crates.iohechoen curso
    2. 02Documentar: rustdoc, /// y docs.rshechoen curso
    3. 03Semver y mantener un cratehechoen curso
    4. 04El ecosistema esencial: las crates que todo Rustacean conocehechoen curso
    5. 05Contribuir y la comunidadhechoen curso
  52. 51

    Nivel 51

    5 temas
    1. 01El pipeline de rustc: del texto fuente al HIRhechoen curso
    2. 02MIR: el grafo donde vive el borrow checkerhechoen curso
    3. 03Monomorfización y codegen: del MIR al código máquinahechoen curso
    4. 04Dentro de rustc: ver los IR y contribuir al compiladorhechoen curso
    5. 05El futuro de Rust y el final del mapahechoen curso