Versión imprimible multipagina. Haga click aquí para imprimir.

Volver a la vista normal de esta página.

Rust

    1. Introduccion
      1. Historia de Rust
        1. Orígenes en Mozilla Research (Graydon Hoare, 2006–2010)
        2. Evolución de prototipos tempranos a Rust 0.x
        3. Lanzamiento de Rust 1.0 (2015)
        4. Consolidación de la estabilidad del lenguaje y del compilador (rustc)
        5. Filosofía de seguridad de memoria sin garbage collector
        6. Filosofía de concurrencia sin miedo (“fearless concurrency”)
        7. Influencia de Cyclone, ML, C++ y el ecosistema de sistemas
        8. Participación comunitaria y apertura del desarrollo
        9. Migración desde la sintaxis antigua (~, @, &) hacia el modelo actual de ownership
        10. Adopción industrial en sistemas embebidos, backend de alto rendimiento y navegadores
        11. Rol de Servo y el motor de renderizado experimental
        12. Influencia de Rust en otros lenguajes de sistemas
      2. Ediciones de Rust y Compatibilidad
        1. Edición 2015
        2. Edición 2018
        3. Edición 2021
        4. Planificación de ediciones futuras (por ejemplo 2024)
        5. Ediciones vs versiones del compilador (rustc)
        6. Estabilidad del lenguaje y promesa de no romper código estable
        7. Estabilidad de la librería estándar (std) y API pública
        8. Uso de lints para migración entre ediciones
        9. Modo cargo fix --edition y migración asistida
        10. Compatibilidad cruzada entre crates de distintas ediciones
        11. Feature flags experimentales en nightly
        12. #![feature(...)] y límites de estabilidad
        13. Cambios de sintaxis entre ediciones
        14. Cambios en el sistema de módulos entre ediciones
        15. Cambios en async/await y try operator entre ediciones
        16. Cambios en paths relativos y absoluta vs crate::
      3. Instalación de Rust
        1. rustup como herramienta oficial de instalación
        2. Canales stable, beta, nightly
        3. Instalación en Windows (MSVC vs GNU toolchain)
        4. Instalación en macOS (homebrew, pkg oficial)
        5. Instalación en Linux (gestores de paquetes vs rustup)
        6. Añadir componentes (rustfmt, clippy)
        7. rustup component add
        8. Targets de compilación cruzada (rustup target add)
        9. Configuración del linker para cross-compiling
        10. Toolchains específicos por proyecto (rust-toolchain.toml)
        11. Versiones fijadas para CI
        12. Perfiles corporativos y espejos internos de toolchain
        13. Instalar cargo en entornos mínimos
        14. Modo offline y caché local de crates
      4. Ejecución de Código Rust y Flujo de Trabajo
        1. rustc archivo.rs
        2. cargo new
        3. cargo init
        4. cargo build
        5. cargo run
        6. cargo check
        7. cargo test básico
        8. cargo bench básico
        9. cargo doc --open
        10. Flags comunes de compilación (--release, --verbose)
        11. Perfiles dev y release
        12. Nivel de optimización (-C opt-level)
        13. RUSTFLAGS y configuración avanzada del compilador
        14. cargo clippy y análisis estático
        15. REPLs experimentales (evcxr)
        16. Scripts rápidos y prototipos con cargo-script
        17. Uso del Playground de Rust
        18. Redirección de stdin/stdout/stderr en binarios Rust
      5. IDEs y Editores de Código
        1. rust-analyzer y protocolo LSP
        2. VS Code con rust-analyzer
        3. IntelliJ Rust / CLion
        4. Vim / Neovim con LSP
        5. Emacs (lsp-mode, eglot)
        6. Autoformato con rustfmt
        7. Sugerencias y acciones rápidas de clippy
        8. Navegación por definiciones y go to definition
        9. Renombrado simbólico seguro (rename refactor)
        10. Depuración con lldb
        11. Depuración con gdb
        12. Mapas de memoria y stepping a nivel de instrucción
        13. Integración con CodeLLDB en VS Code
        14. Integración con herramientas de profiling
        15. Soporte de test integrado en el IDE
        16. Integración con cargo watch para recarga continua
      6. Gestión de Dependencias y Entornos
        1. cargo como build system y gestor de dependencias
        2. Cargo.toml
        3. Cargo.lock
        4. Versionado semántico en dependencias ("1.2", "^1.2", "~1.2")
        5. Dependencias opcionales (optional = true)
        6. Features activables por crate
        7. Workspaces de Cargo
        8. Herencia de workspace en Cargo.toml
        9. Dependencias locales (path =)
        10. Dependencias desde Git
        11. Overrides de versiones ([patch])
        12. Mirrors y registries privados
        13. Vendorización de crates (cargo vendor)
        14. Caché local de compilación incremental
        15. Reproducibilidad entre entornos
        16. Compilación determinista para entrega binaria
        17. Bloqueo de versiones en CI
        18. Auditoría de dependencias (cargo audit)
      7. Distribución de Crates
        1. Crates binarios
        2. Crates de librería
        3. Crates proc-macro
        4. Crates no_std
        5. Crates FFI (cdylib, staticlib)
        6. Publicación en crates.io
        7. cargo publish
        8. cargo yank
        9. Versionado semántico responsable
        10. Metadatos obligatorios en Cargo.toml
        11. Licencia y license/license-file
        12. readme y documentación pública
        13. Keywords y categorías
        14. exclude / include
        15. Seguridad de la cadena de suministro
        16. Firmas y verificación de integridad
        17. Auditoría de licencias (cargo deny)
        18. Revisión por pares y mantenimiento comunitario
      8. Herramientas Complementarias
        1. rustfmt (formato)
        2. clippy (linter)
        3. cargo doc (documentación)
        4. cargo test (testing)
        5. cargo bench (benchmarking)
        6. cargo profile / perfiles de rendimiento
        7. cargo tree (árbol de dependencias)
        8. cargo metadata
        9. cargo install
        10. cargo uninstall
        11. cargo run --release
        12. cargo build --target
        13. cargo fix
        14. cargo fmt
        15. cargo clippy --fix
        16. Integración con CI/CD
        17. Integración con contenedores
        18. Integración con sistemas de empaquetado nativo
        19. Reproducibilidad en builds herméticos
        20. Automatización con Makefile y just
    2. Fundamentos
      1. Tipos de Datos Básicos
        1. Variables y let
          1. Declaración con inferencia de tipo
          2. Anotación explícita de tipo
          3. Mutabilidad con mut
          4. Sombras (shadowing) y redeclaración
          5. Variables temporales y scope de bloque
          6. const para constantes en tiempo de compilación
          7. static y static mut
        2. Booleanos (bool)
        3. Tipos numéricos escalares
          1. Enteros con signo (i8, i16, i32, i64, i128, isize)
          2. Enteros sin signo (u8, u16, u32, u64, u128, usize)
          3. Flotantes (f32, f64)
          4. Literales numéricos con separadores _
          5. Conversión entre anchos de entero
          6. Casting con as
          7. Operaciones “checked”, “wrapping”, “saturating”
          8. Módulo std::num
          9. Rangos y límites (MIN, MAX)
        4. Caracteres y texto
          1. char como escalar Unicode
          2. Literales de carácter
          3. &str (slice de string inmutable)
          4. String (buffer dinámico UTF-8)
          5. Conversión entre &str y String
          6. String::from y .to_string()
          7. Indexación y slicing seguro en UTF-8
          8. Formato con macros (format!, println!)
          9. Cow<'a, str>
          10. OsStr y OsString
          11. Path y PathBuf
        5. Tuplas
          1. Tuplas con nombre posicional
          2. Tuple structs
          3. Desestructuración de tuplas
          4. Retorno múltiple con tuplas
          5. Tupla vacía ()
          6. () como tipo unit
        6. Arrays y slices
          1. Arrays fijos [T; N]
          2. Slices &[T]
          3. Slices mutables &mut [T]
          4. Indexación segura y get()
          5. Recortes (split_at, chunks, windows)
          6. Slices de bytes (&[u8])
          7. Conversión de arrays a slices
        7. Propiedad y move
          1. Propiedad exclusiva de valores
          2. Movimiento vs copia (Copy)
          3. Clone explícito
          4. Tipos Copy
          5. Tipos que no son Copy
          6. Transferencia de propiedad a funciones
          7. Retorno de propiedad desde funciones
        8. Préstamos y referencias
          1. Referencias inmutables &T
          2. Referencias mutables &mut T
          3. Reglas de aliasing único para mutables
          4. Duración del préstamo (lifetime implícito)
          5. Prestando vs moviendo
          6. Mutabilidad interior
          7. Reglas de borrow checker
        9. Lifetimes
          1. Parámetros de lifetime explícitos ('a)
          2. Elision de lifetimes
          3. Relaciones de subvida ('a: 'b)
          4. Lifetimes en referencias de retorno
          5. Lifetimes en structs
          6. Lifetimes en métodos impl
          7. 'static
          8. Lifetimes en closures
        10. Enumeraciones (enum)
        11. Variantes sin datos
        12. Variantes tipo tupla
        13. Variantes tipo struct
        14. Patrones exhaustivos con match
        15. Option<T>
        16. Result<T, E>
        17. Ordering
        18. Never type (!)
        19. Structs
        20. Structs con campos nombrados
        21. Tuple structs
        22. Unit structs
        23. pub y visibilidad de campos
        24. Inicialización con sintaxis { campo: valor }
        25. Actualización de struct (..otro)
        26. Propiedad de campos y movimientos parciales
        27. Empaquetar datos y semántica de valor
        28. Traits básicos
        29. Copy
        30. Clone
        31. Debug
        32. Display
        33. Default
        34. PartialEq / Eq
        35. PartialOrd / Ord
        36. Hash
        37. Send
        38. Sync
        39. Unpin
        40. Sized
        41. Conversión y coerción
        42. From / Into
        43. TryFrom / TryInto
        44. AsRef / AsMut
        45. Borrow
        46. Deref / DerefMut
        47. Auto-deref en llamadas a métodos
        48. Conversión numérica con as
        49. Conversión de slices entre tipos compatibles
        50. Pattern matching de destructuración
        51. let + patrones
        52. if let
        53. while let
        54. Patrones en parámetros de función
        55. Patrones en match
        56. Patrones anidados en structs y enums
        57. Patrones con guardas (if)
        58. Patrones con @
        59. Patrones con _
        60. Patrones de rango (..=)
      2. Operadores
        1. Operadores aritméticos (+, -, *, /, %)
        2. Operadores de asignación compuesta (+=, -=, *=, /=, %=)
        3. Operadores bit a bit (&, |, ^, !, <<, >>)
        4. Comparación (==, !=, <, >, <=, >=)
        5. Operadores lógicos (&&, ||, !)
        6. Precedencia de operadores
        7. Evaluación corta (short-circuit) en && y ||
        8. Operador de rango (.., ..=)
        9. Desreferenciación (*)
        10. Indexación ([])
        11. ? para propagación de errores
        12. as para casting explícito
        13. Operador ref en patrones
        14. box (histórico) y Box::new
        15. .. en patrones de struct
        16. .. en patrones de tuplas y enums
        17. & y &mut en patrones de referencia
        18. | en patrones alternativos en match
        19. @ en patrones con binding
        20. .. en ranges de iteración
      3. Control de Flujo
        1. if
        2. else if
        3. else
        4. if como expresión
        5. match
        6. match exhaustivo
        7. match con guardas (if cond)
        8. match con patrones anidados
        9. if let
        10. while
        11. while let
        12. loop
        13. for
        14. Rango en for
        15. break
        16. continue
        17. return
        18. Etiquetas de bucle ('label:)
        19. break 'label
        20. continue 'label
        21. let else para validación temprana
        22. try blocks experimentales
        23. panic! como corte de control
        24. unreachable! y todo!
        25. assert! y control en test
      4. Funciones
        1. Definición de funciones con fn
        2. Parámetros con tipo explícito
        3. Retorno con ->
        4. Retorno implícito sin return
        5. Funciones libres vs métodos asociados
        6. Métodos en impl
        7. Métodos estáticos (fn new())
        8. Referencias &self
        9. Referencias &mut self
        10. Funciones genéricas
        11. Trait bounds en firmas (where)
        12. Lifetimes explícitos en firmas
        13. Funciones const fn
        14. Funciones unsafe fn
        15. Funciones extern "C"
        16. Funciones inline (#[inline])
        17. Atributos en funciones (#[must_use], #[cold], #[inline(always)])
        18. Punteros a función (fn vs Fn traits)
        19. macro_rules! vs fn
        20. Visibilidad pub en funciones
      5. Closures
        1. Sintaxis |args| expr
        2. move closures
        3. Inferencia de tipos en closures
        4. Captura por referencia
        5. Captura por mutable referencia
        6. Captura por movimiento
        7. Traits Fn, FnMut, FnOnce
        8. Conversión de closures a punteros de función
        9. Almacenamiento de closures en Box<dyn Fn>
        10. Lifetimes en closures
        11. Uso de closures en iteradores
        12. Uso de closures en APIs async
        13. Cierres como callbacks en FFI seguro
        14. impl Fn en parámetros
        15. impl FnOnce para consumo de recursos
      6. Manejo de Errores
        1. Result<T, E>
        2. Option<T>
        3. Operador ?
        4. unwrap
        5. expect
        6. ok_or / ok_or_else
        7. map_err
        8. and_then
        9. Definir tipos de error propios
        10. Trait std::error::Error
        11. Errores encadenados
        12. thiserror (crates de error derivado)
        13. Manejo de errores en main
        14. Devolución de Result desde main
        15. panic!
        16. Recuperación después de panic con catch_unwind
        17. assert!, assert_eq!, debug_assert!
        18. todo!
        19. unimplemented!
        20. unreachable!
      7. Prelude y Librería Estándar
        1. std::prelude
        2. Carga automática del prelude
        3. Tipos fundamentales en el prelude
        4. Traits fundamentales en el prelude
        5. std vs core
        6. alloc en entornos no_std
        7. use std::... y rutas absolutas
        8. pub use para reexportar APIs
        9. std::io
        10. std::fs
        11. std::env
        12. std::path
        13. std::time
        14. std::thread
        15. std::sync
        16. std::net
        17. std::process
        18. std::mem
        19. std::ptr
        20. std::slice
        21. std::str
        22. std::string
        23. std::vec
      8. Módulos y Visibilidad
        1. mod
        2. Archivos y submódulos
        3. Jerarquía de módulos (crate, super, self)
        4. pub
        5. pub(crate)
        6. pub(super)
        7. pub(in path)
        8. use
        9. use as
        10. Reexport con pub use
        11. Separación binario / librería (src/main.rs, src/lib.rs)
        12. Árbol de módulos y layout de carpetas
        13. Módulos privados internos
        14. Módulos cfg condicionales
        15. #[path = "file.rs"]
        16. extern crate (histórico)
        17. crate:: paths absolutos
        18. super:: paths relativos
        19. Módulos inline { ... }
        20. Tests integrados en módulos (#[cfg(test)])
      9. Atributos y Macros Básicas
        1. Atributos en ítems (#[derive], #[inline], #[allow])
        2. Atributos en módulos (#![allow], #![deny])
        3. Atributos de lint (#[warn(clippy::...)])
        4. Macros declarativas macro_rules!
        5. Macros de formato (println!, eprintln!, format!)
        6. Macros de colección (vec!, vecDeque! en crates externos)
        7. Macros de aserción (assert!, debug_assert!)
        8. Macros de error (panic!)
        9. Macros condicionales (cfg!)
        10. Macros de test (#[test])
        11. Macros de derivación automática (#[derive(Clone, Debug, ...)])
      10. Atributos de Compilación Condicional
      11. #[cfg(target_os = "linux")]
      12. #[cfg(target_arch = "x86_64")]
      13. #[cfg(feature = "foo")]
      14. #[cfg(test)]
      15. #[cfg(debug_assertions)]
      16. #[cfg_attr(...)]
      17. cfg_if! (macro de conveniencia)
      18. Builds multiplataforma con cfg
      19. Código específico de arquitectura
      20. Desactivación de partes inseguras en WASM
      21. Estándares de Estilo
      22. Formato con rustfmt
      23. Organización de use
      24. Nomenclatura de tipos (PascalCase)
      25. Nomenclatura de variables y funciones (snake_case)
      26. Constantes (SCREAMING_SNAKE_CASE)
      27. División en módulos pequeños
      28. Comentarios /// para docs públicas
      29. Comentarios //! a nivel de crate
      30. Comentarios de implementación //
      31. #[allow] vs #[deny] para lints
      32. Políticas internas de clippy
      33. Reglas de API públicas estables
      34. Visibilidad mínima (pub vs pub(crate))
      35. Convenciones de Proyecto
      36. src/main.rs
      37. src/lib.rs
      38. src/bin/*.rs
      39. Cargo.toml
      40. Cargo.lock
      41. README.md
      42. LICENSE
      43. rust-toolchain.toml
      44. benches/
      45. examples/
      46. tests/
      47. build.rs
      48. target/
      49. Módulos internos mod.rs vs foo.rs
      50. Estructura por dominio
      51. Estructura por capas (core, infra, api)
      52. Reexportar APIs en lib.rs
      53. #[deny(missing_docs)]
      54. Versionado del crate
      55. Features opcionales y default-features = false
    3. Estructuras y manipulación de datos
      1. Colecciones Estándar
        1. Vec<T>
        2. Creación y vec![]
        3. Push / pop
        4. Indexación y .get()
        5. Iteración mutable e inmutable
        6. Reservar capacidad (with_capacity, reserve)
        7. insert, remove
        8. retain
        9. sort, sort_by, sort_unstable
        10. dedup
        11. drain
        12. Conversión Vec<T> ↔ slice
        13. VecDeque<T>
        14. VecDeque push_front / push_back
        15. LinkedList<T>
        16. BinaryHeap<T>
        17. HashMap<K, V>
        18. BTreeMap<K, V>
        19. HashSet<T>
        20. BTreeSet<T>
        21. IndexMap, IndexSet (orden estable, crates externos)
        22. SmallVec, ArrayVec (almacenamiento en stack)
        23. Cow<T>
        24. Range
        25. Option<T> como colección parcial
        26. Result<T,E> como flujo condicional
        27. APIs de iteradores en colecciones
        28. String y Vec<u8>
        29. Box<[T]>
        30. Rc<[T]> y Arc<[T]>
      2. Pilas y Colas
        1. Vec<T> como pila LIFO
        2. VecDeque<T> como cola FIFO
        3. BinaryHeap<T> como cola de prioridad
        4. Múltiples productores / múltiples consumidores usando canales
        5. Estructuras lock-free con crossbeam (crates externos)
        6. Colas concurrentes en tokio::sync
        7. std::sync::mpsc
        8. Orden de mensajes garantizado
        9. try_recv / recv_timeout
        10. Backpressure en colas async
      3. Slicing y Vistas
        1. Slices &[T]
        2. Slices mutables &mut [T]
        3. Vistas parciales (split_at, split)
        4. Ventanas (windows)
        5. Chunks (chunks, chunks_exact)
        6. array_chunks y vistas fijas
        7. as_slice / as_mut_slice
        8. str como slice de u8 UTF-8
        9. Slices crudas (*const T, *mut T)
        10. std::slice::from_raw_parts
        11. Reglas de seguridad en slices no verificados
      4. Manipulación de Strings
        1. String
        2. &str
        3. Concatenación con push_str
        4. Concatenación con +
        5. Formato con format!
        6. Interpolación con println!
        7. Iteración por bytes
        8. Iteración por char
        9. Iteración por grapheme (crates externos)
        10. Substrings seguras por rango de bytes válidos
        11. Búsqueda (find, contains)
        12. Reemplazo (replace)
        13. Divisiones (split, split_whitespace)
        14. trim, trim_matches
        15. Conversión entre OsString, PathBuf, String
        16. to_string_lossy
        17. Normalización Unicode (crates externos)
        18. Cow<'_, str> para evitar copias
        19. Propiedad vs referencia en APIs de texto
        20. String::leak
      5. Expresiones Regulares y Parsing
        1. Crate regex
        2. Expresiones regulares compiladas
        3. Búsquedas globales
        4. Capturas con grupos
        5. Reemplazo con patrones
        6. División por regex
        7. Expresiones regulares sin backtracking exponencial
        8. lazy_static / once_cell para regex globales
        9. regex-automata (crates especializadas)
        10. Parsing manual con chars()
        11. Parsing con nom
        12. Parsers basados en combinadores
        13. Parsing binario con nom / binrw
        14. serde para deserialización estructurada
      6. Archivos y I/O
        1. std::fs::File
        2. File::open
        3. File::create
        4. Lectura síncrona (read_to_end, read_to_string)
        5. Escritura síncrona (write_all)
        6. BufReader
        7. BufWriter
        8. Lectura línea a línea (read_line)
        9. Iteración sobre líneas
        10. Permisos de archivo (set_permissions)
        11. metadata
        12. Directorios (read_dir)
        13. Creación y borrado de carpetas
        14. Renombrar y mover archivos
        15. Rutas (Path, PathBuf)
        16. std::env::current_dir
        17. tempfile (crates externos)
        18. Archivos mapeados en memoria (crates externos)
        19. I/O sin bloqueo en tokio::fs
        20. I/O con async-std::fs
      7. Formatos de Datos
        1. JSON con serde_json
        2. TOML con toml
        3. YAML con serde_yaml
        4. CBOR / MessagePack (crates externos)
        5. Protobuf / FlatBuffers (crates externos)
        6. CSV con csv
        7. Lectura binaria con byteorder
        8. Escritura binaria con byteorder
        9. Manipulación de bits en buffers (bitvec)
        10. Serialización binaria con bincode
        11. serde derive (Serialize, Deserialize)
        12. Versionado de esquemas
        13. Migración de estructuras serializadas
        14. Validación de datos deserializados
      8. Fechas y Tiempo
        1. std::time::Duration
        2. std::time::Instant
        3. std::time::SystemTime
        4. Diferencias de tiempo (duration_since)
        5. Timeouts en I/O
        6. Retrasos y sleep con std::thread::sleep
        7. Retrasos async con tokio::time::sleep
        8. Medición de rendimiento
        9. Perfiles de latencia
        10. Crate chrono (fecha/hora civil)
        11. Zonas horarias con chrono_tz
        12. Formateo de timestamps
        13. Parsing de timestamps
        14. Sincronización periódica y scheduling (crates externos)
        15. Timers async recurrentes (crates async)
      9. Propiedad Compartida y Gestión de Recursos
        1. Box<T>
        2. Rc<T>
        3. Arc<T>
        4. Cell<T>
        5. RefCell<T>
        6. Mutex<T>
        7. RwLock<T>
        8. OnceCell<T>
        9. LazyLock<T>
        10. AtomicBool, AtomicUsize, etc.
        11. Conteo de referencias y ciclos
        12. Fugas deliberadas (Box::leak)
        13. Smart pointers específicos de librería
        14. RAII y liberación determinista con Drop
      10. Iteradores
      11. Iterator trait
      12. .next()
      13. for sobre iteradores
      14. Adaptadores (map, filter, flat_map)
      15. enumerate
      16. zip
      17. chain
      18. rev
      19. take, skip
      20. collect
      21. Colección en Vec
      22. Colección en HashMap
      23. Iteradores infinitos y std::iter::repeat
      24. std::iter::from_fn
      25. inspect
      26. fold
      27. try_fold
      28. Propiedad vs referencia en iteradores
      29. Iteradores que consumen (into_iter)
      30. Iteradores prestados (iter, iter_mut)
      31. Iteradores paralelos (rayon)
      32. Iteradores async (Stream en ecosistema async)
      33. Expresiones Funcionales y Pipelines
      34. .map(...)
      35. .filter(...)
      36. .filter_map(...)
      37. .find(...)
      38. .any(...)
      39. .all(...)
      40. .position(...)
      41. .fold(...)
      42. .reduce(...)
      43. .group_by(...) (crates externos)
      44. Transformaciones in-place vs alocar nuevos Vec
      45. Reutilización de buffers
      46. Zero-copy usando slices
      47. Evitar clonados innecesarios
      48. Cow en pipelines de texto
      49. Seguridad y Manejo Binario
      50. std::mem::transmute (uso inseguro)
      51. std::mem::replace
      52. std::mem::take
      53. MaybeUninit<T>
      54. Layout de memoria (#[repr(C)], #[repr(packed)])
      55. Alineación (align_of, align_to)
      56. Lectura/escritura de bytes con byteorder
      57. Endianness explícito
      58. Acceso crudo con punteros (*const T, *mut T)
      59. slice::from_raw_parts
      60. ptr::copy_nonoverlapping
      61. Control de aliasing en unsafe
      62. Serialización binaria para FFI
      63. Mapear estructuras Rust a C
    4. Programación estructurada y modular
      1. Programación Orientada a Datos y Traits
        1. Structs como tipos de datos centrales
        2. impl blocks
        3. Métodos asociados
        4. Métodos que consumen self
        5. Métodos que prestan &self
        6. Métodos que prestan &mut self
        7. Encapsulación con campos privados
        8. Getters explícitos
        9. Constructores estilo new()
        10. Builders encadenables
        11. Propiedades inmutables por defecto
        12. APIs seguras por tipo
        13. APIs que evitan estados inválidos
        14. Patrón tipo-sello (sealed traits en módulos privados)
        15. Patrón unsafe encapsulado en capa segura
      2. Traits e Implementaciones
        1. Definición de trait
        2. Métodos requeridos
        3. Métodos con implementación por defecto
        4. Implementación de traits para tipos propios
        5. Implementación de traits externos para tipos propios (coherencia)
        6. Implementación de traits propios para tipos externos (orfan rule)
        7. Traits marcadores (Send, Sync, Unpin)
        8. Traits auto (auto trait)
        9. dyn Trait
        10. Trait objects (&dyn Trait, Box<dyn Trait>)
        11. Dispatch dinámico vs estático
        12. Traits genéricos
        13. Associated types en traits
        14. Supertraits
        15. where bounds complejos
        16. Implementaciones en impl<T> Trait for Tipo<T>
        17. Coerción de &T a &dyn Trait
        18. Objetos trait en interfaces plugin
        19. Objetos trait y Send + Sync
        20. Limitaciones de objetos trait (no Self en firma)
      3. Encapsulación y Abstracción
        1. Visibilidad pub
        2. Visibilidad pub(crate)
        3. Visibilidad pub(super)
        4. Campos privados y módulos amigos
        5. Patrones con newtype
        6. Patrones de estado interno protegido
        7. API mínima segura
        8. Diseño de invariantes internas
        9. Tipos fantasma (phantom types)
        10. PhantomData<T>
        11. Tipos con lifetimes en la API pública
        12. Sellado de traits para evitar implementaciones externas
      4. Composición vs Herencia
        1. Composición de structs
        2. Contención de datos (struct A { b: B })
        3. Delegación manual de métodos
        4. Deref para ergonomía de delegación
        5. Herencia ausente en el lenguaje base
        6. Subtipado vía traits
        7. Polimorfismo paramétrico (genéricos)
        8. Polimorfismo dinámico (trait objects)
        9. Patrones de tipo estado (state pattern)
        10. Patrones de builder tipado
        11. Patrones GADT a través de enums
        12. Patrones de “typestate programming”
      5. Macros de Atributo y Derive
        1. #[derive(Debug)]
        2. #[derive(Clone)]
        3. #[derive(Copy)]
        4. #[derive(PartialEq, Eq)]
        5. #[derive(PartialOrd, Ord)]
        6. #[derive(Hash)]
        7. #[derive(Default)]
        8. #[derive(Serialize, Deserialize)]
        9. Atributos en campos (#[serde(rename = "...")])
        10. Procedural macros (proc-macro)
        11. #[test]
        12. #[bench] (inestable / crates externos)
        13. #[cfg(...)]
        14. #[inline]
        15. #[must_use]
        16. #[repr(C)]
        17. #[repr(packed)]
        18. #[non_exhaustive]
        19. #[deny(...)], #[allow(...)], #[warn(...)]
        20. Atributos específicos de plataforma
      6. Módulos y Crates (avanzado)
        1. Crates binarios
        2. Crates librería
        3. Crates internos en un workspace
        4. Árbol de módulos público (lib.rs)
        5. Reexportar símbolos (pub use)
        6. Organización por dominio
        7. Organización por capa lógica
        8. Patrones prelude internos
        9. #[doc(hidden)]
        10. #[path]
        11. include!
        12. include_bytes!
        13. include_str!
        14. build.rs para generar código
        15. OUT_DIR y artefactos generados
        16. cfg(feature = "...")
        17. cfg(target_os = "...")
        18. cfg(test)
        19. Tests de integración en tests/
        20. Ejemplos en examples/
      7. Logging
        1. Crate log
        2. Macros info!, warn!, error!, debug!, trace!
        3. Backends (env_logger, fern, tracing)
        4. Niveles de log
        5. Filtros de log por módulo
        6. Logging estructurado con tracing
        7. tracing::span y tracing::instrument
        8. Exportar logs a JSON
        9. Logs en aplicaciones CLI
        10. Logs en servicios async
        11. Logs en entornos no_std (semihosting / ITM)
        12. Rotación de logs (crates externos)
        13. Formato con timestamps
        14. Integración con observabilidad
        15. Uso de log en librerías reutilizables
      8. Documentación
        1. Comentarios ///
        2. Comentarios //! a nivel de crate o módulo
        3. Ejemplos en documentación
        4. cargo doc
        5. cargo doc --open
        6. Documentación pública mínima
        7. #[doc(hidden)]
        8. #[deny(missing_docs)]
        9. Mostrar ejemplos que compilan
        10. Ejecución de ejemplos como tests doctest
        11. Documentar invariantes de seguridad
        12. Documentar unsafe
        13. Documentar lifetimes y ownership
        14. Documentar errores (Result)
        15. Políticas de versionado semántico en docs
        16. Guías de “cómo usar” en módulos raíz
        17. Ejemplos por feature flag
        18. Docs generadas para crates internos
        19. Publicación de docs en hosting estático
        20. Documentación interna vs externa
      9. Testing
        1. #[test]
        2. cargo test
        3. Tests de unidad
        4. Tests de integración (tests/)
        5. Tests de documentación (doctests)
        6. assert!
        7. assert_eq!
        8. assert_ne!
        9. matches!
        10. should_panic
        11. Tests con Result<(), E>
        12. Tests async con runtimes (#[tokio::test])
        13. Tests parametrizados (macros de terceros)
        14. Fixtures simuladas manualmente
        15. tempfile para tests con disco
        16. Pruebas con proptest (property-based testing)
        17. Pruebas fuzzing (cargo fuzz)
        18. Pruebas de snapshot (insta)
        19. Pruebas de rendimiento (criterion)
        20. Cobertura de código (cargo tarpaulin)
        21. #[cfg(test)] secciones privadas de prueba
        22. Tests de concurrencia y race conditions
        23. Tests de integración multinodo / multi-hilo
        24. Mocking de dependencias (crates mockall, etc.)
        25. Simulación de redes con sockets falsos
        26. Tests deterministas de tiempo (fake_time)
        27. Tests con canal mpsc local
        28. Tests que validan Send + Sync
        29. Tests de unsafe correctness
        30. Validación de invariantes de memoria
      10. Depuración
      11. dbg! macro
      12. println! debug
      13. Debug derivado (#[derive(Debug)])
      14. Revisar panic backtraces (RUST_BACKTRACE=1)
      15. gdb
      16. lldb
      17. Depuración con VS Code (CodeLLDB)
      18. Breakpoints en código Rust
      19. Inspección de variables y lifetimes
      20. Desensamblado de código generado
      21. Inspección de ensamblador (rustc --emit asm)
      22. Inspección de MIR (rustc --emit mir, nightly)
      23. Inspección de LLVM IR (--emit llvm-ir)
      24. Validación de alineación de punteros
      25. Detección de UB potencial usando miri
      26. Análisis con sanitizers (ASan, UBSan)
      27. Chequeo de data races con ThreadSanitizer
      28. Validación de límites con AddressSanitizer
      29. Depuración de bloqueo mutuo (deadlock)
      30. Depuración de rendimiento con perf
      31. Flamegraphs
      32. Inspección de heap con herramientas externas
      33. Registros de tracing con tracing + tokio-console
      34. Pruebas de estrés para reproducir condiciones de carrera
      35. Auditoría manual de unsafe
    5. Estructuras avanzadas y programación funcional
      1. Programación Funcional y Estilo Declarativo
        1. Rust como lenguaje orientado a expresiones
        2. Expresiones en lugar de sentencias
        3. Cierres (|...| ...)
        4. Inmutabilidad preferida
        5. map, filter, fold
        6. flat_map
        7. Composición con iteradores
        8. Option como mónada de presencia/ausencia
        9. Result como mónada de éxito/error
        10. Encadenamiento con and_then
        11. Encadenamiento con map_err
        12. Control de flujo sin panic
        13. Early returns con ?
        14. if let como destructuración parcial
        15. match como eliminación exhaustiva de casos
        16. match anidado para composición de lógica
        17. let else para validaciones
        18. Uso de From / Into para componer transformaciones
        19. Tipos de dominio con invariantes fuertes
        20. Errores tipados en lugar de excepciones
      2. Iteradores / Adaptadores / Streams
        1. Iterator trait
        2. Adaptadores estándar (map, filter, take, skip, enumerate)
        3. Adaptadores de flattening (flat_map, flatten)
        4. Adaptadores de búsqueda (find, position, rposition)
        5. Adaptadores de acumulación (fold, scan)
        6. Adaptadores de partición (partition, group_by con crates externos)
        7. Iteradores infinitos (repeat, successors)
        8. Iteradores sobre Result
        9. try_fold
        10. Paralelización con rayon::prelude::*
        11. Iteradores paralelos (par_iter, par_chunks)
        12. Recolección en Vec, HashMap, BTreeMap
        13. Iteradores mutables (iter_mut)
        14. Iteradores que consumen (into_iter)
        15. Iteradores sobre referencias (iter)
        16. Iteradores sobre slices (slice::Chunks, ChunksExact)
        17. Iteradores de archivos línea a línea
        18. Iteradores de sockets TCP
        19. Stream en async (futures::stream)
        20. Combinadores async (stream::map, stream::buffer_unordered)
      3. Punteros Inteligentes y Mutabilidad Interior
        1. Box<T>
        2. Rc<T>
        3. Arc<T>
        4. Cell<T>
        5. RefCell<T>
        6. Mutex<T>
        7. RwLock<T>
        8. AtomicBool, AtomicUsize, AtomicPtr
        9. Arc<Mutex<T>>
        10. Arc<RwLock<T>>
        11. OnceCell<T>
        12. LazyLock<T>
        13. Weak<T>
        14. Ciclos con Rc y fuga de memoria lógica
        15. Romper ciclos con Weak
        16. Interior mutability patterns
        17. Single-thread vs multi-thread (Rc vs Arc)
        18. Envolturas seguras para FFI
        19. Gestión de recursos externos (file handles, sockets)
        20. RAII con Drop
      4. Benchmarking y Perfilado
        1. cargo bench
        2. Crate criterion para benchmarks estadísticos
        3. Microbenchmarks de funciones puras
        4. Benchmarks con acceso a disco
        5. Benchmarks de red
        6. Perfiles de CPU con perf
        7. Perfiles de CPU con dtrace / eBPF
        8. Flamegraphs
        9. Análisis de asignaciones con valgrind / heaptrack
        10. Instrumentación manual con timestamps (Instant::now)
        11. Contadores internos de rendimiento
        12. Benchmarks de throughput vs latency
        13. Impacto de clone en hot paths
        14. Reducción de alloc en loops críticos
        15. Caches locales (HashMap interno)
        16. Inlining agresivo (#[inline(always)])
        17. Branch prediction hints (patrones de if likely usando crates externos)
        18. Mediciones en modo --release
        19. Evitar TLE bloqueando IO
        20. Ensamblador generado (rustc --emit asm)
      5. Herramientas de Calidad de Código
        1. rustfmt para formateo automático
        2. clippy para lints
        3. cargo clippy --fix
        4. Lints de estilo
        5. Lints de rendimiento
        6. Lints de correctitud
        7. Lints de seguridad (uso de unsafe)
        8. Lints de complejidad
        9. Reglas internas de equipos (#![deny(warnings)])
        10. Revisiones de unsafe en PRs
        11. Auditorías de unsafe en librerías públicas
        12. Control de deuda técnica
        13. cargo deny para licencias y vulnerabilidades
        14. cargo audit para CVEs
        15. cargo udeps para dependencias no usadas
        16. cargo outdated para versiones antiguas
        17. cargo machete / cargo trim (limpieza de dependencias)
        18. Políticas de versión mínima soportada (MSRV)
        19. Análisis estático adicional con sanitizers
        20. Integración en CI (rustfmt --check, clippy -- -D warnings)
      6. Seguridad de Memoria y Concurrencia
        1. Ausencia de null en tipos seguros (Option<T>)
        2. Ausencia de use after free bajo safe Rust
        3. Propiedad y lifetimes como contrato de seguridad
        4. Send
        5. Sync
        6. Send + Sync en tipos concurrentes
        7. Arc<Mutex<T>> para compartir estado
        8. RwLock para lecturas concurrentes
        9. Canales MPSC (std::sync::mpsc)
        10. Canales múltiples productores múltiples consumidores (crossbeam)
        11. Sincronización sin bloqueo (lock-free)
        12. Atomics (Ordering)
        13. Deadlocks y estrategias de evitación
        14. Condiciones de carrera y unsafe
        15. Problemas de memoria ABA en atomics
        16. Reglas de aliasing exclusivas
        17. &mut T como garantía de acceso exclusivo
        18. Verificación en tiempo de compilación vs runtime
        19. Compartir memoria en async sin Send (!Send futures)
        20. Minimizar unsafe en código concurrente
      7. Sistema de Tipos Avanzado
        1. Genéricos (fn foo<T>(x: T))
        2. impl Trait en retorno
        3. impl Trait en parámetros
        4. where bounds complejos
        5. Traits con tipos asociados
        6. Traits con constantes asociadas
        7. Traits con lifetimes asociados
        8. Const generics (const N: usize)
        9. Arreglos genéricos [T; N] con const N
        10. PhantomData<T>
        11. Tipos marca (marker types)
        12. ! (never type)
        13. Tipos vacíos
        14. Tipos que no pueden construirse externamente
        15. enum no exhaustivos (#[non_exhaustive])
        16. Patrones sealed trait
        17. Coherencia de traits (orphan rules)
        18. Auto traits (Send, Sync)
        19. Sized y ?Sized
        20. Trait objects y dyn Trait
        21. Subtipado con lifetimes distintas
        22. Higher-Rank Trait Bounds (HRTB, for<'a>)
        23. Fn, FnMut, FnOnce
        24. Unpin
        25. Pin<P>
        26. Drop
        27. ManuallyDrop<T>
        28. MaybeUninit<T>
        29. Unsafe traits
        30. Límite entre safe Rust y unsafe Rust
    6. Concurrencia, Async, Bajo Nivel
      1. Async y Concurrencia
        1. Hilos (std::thread::spawn)
        2. JoinHandle
        3. move closures en threads
        4. Arc<T> para compartir datos entre hilos
        5. Mutex<T> para exclusión mutua
        6. RwLock<T> para lectura concurrente
        7. Barreras (Barrier)
        8. Canales std::sync::mpsc
        9. sync::mpsc::Sender / Receiver
        10. Canales crossbeam
        11. Canales tokio::sync::mpsc
        12. Semáforos async (tokio::sync::Semaphore)
        13. Condvar
        14. AtomicBool, AtomicUsize, etc.
        15. Fences de memoria (Ordering)
        16. Evitar data races con Send y Sync
        17. Send automático para la mayoría de tipos
        18. Tipos que no son Send
        19. Compartir file descriptors entre hilos
        20. Compartir conexiones de red
        21. Pools de hilos
        22. rayon para paralelismo de datos
        23. rayon::join
        24. par_iter
        25. Balanceo de carga de trabajo
        26. Uso de #[derive(Clone)] para handles ligeros
        27. Cancelación cooperativa entre hilos
        28. Pruebas de concurrencia
        29. Deadlock debugging
        30. Escalabilidad en CPU multinúcleo
      2. Async/await
        1. async fn
        2. async { ... } bloques
        3. await
        4. Future trait (std::future::Future)
        5. Pin
        6. Unpin
        7. Box<dyn Future<Output = T> + Send>
        8. impl Future<Output = T>
        9. Ejecutores (tokio, async-std, smol)
        10. tokio::spawn
        11. tokio::select!
        12. Canales async (tokio::sync::mpsc)
        13. Mutex async (tokio::sync::Mutex)
        14. RwLock async
        15. Temporizadores async (tokio::time::sleep)
        16. Timeouts (tokio::time::timeout)
        17. Streams async (futures::stream::Stream)
        18. Backpressure en streams async
        19. Conexiones persistentes async
        20. I/O no bloqueante (tokio::net)
        21. Sockets TCP async
        22. Sockets UDP async
        23. WebSockets async
        24. Sincronización en single-threaded runtime
        25. Send y Sync en futures
        26. !Send futures y LocalSet
        27. task::yield_now y cooperación
        28. Cancelación de tareas async
        29. Reintentos con delays exponenciales
        30. Recolección de JoinHandle async
      3. Redes y Comunicación
        1. std::net::TcpListener
        2. std::net::TcpStream
        3. std::net::UdpSocket
        4. Modo bloqueante
        5. Modo no bloqueante (set_nonblocking)
        6. Lectura/escritura con Read / Write
        7. Buffers ([u8])
        8. Gestión de errores de red (io::Result)
        9. Timeouts de socket
        10. Reintentos de conexión
        11. Serialización de mensajes (bincode, serde)
        12. Protocolos binarios personalizados
        13. HTTP cliente (reqwest)
        14. HTTP servidor (hyper, axum, warp, actix-web)
        15. WebSockets (crates externos)
        16. TLS (rustls)
        17. Certificados propios
        18. Protocolos binarios de baja latencia
        19. RPC (tonic gRPC)
        20. Streaming bidireccional
        21. Backpressure en servidores async
        22. Balanceo de carga
        23. Sharding de conexiones
        24. Pools de conexión
        25. Control de congestión a nivel de aplicación
        26. Telemetría de latencia y throughput
        27. Límite de tasa (rate limiting)
        28. Cortafuegos lógico a nivel de aplicación
        29. Instrumentación con tracing
        30. Testing de red con sockets falsos
      4. Metaprogramación
        1. Macros declarativas macro_rules!
        2. Macros con repeticiones ($()*)
        3. Macros con capturas de tokens
        4. Macros que generan código repetitivo
        5. Macros para logs (info!, debug!, trace!)
        6. Macros de aserción (assert!, assert_eq!, matches!)
        7. Procedural macros #[proc_macro]
        8. Procedural macros #[proc_macro_derive]
        9. Procedural macros #[proc_macro_attribute]
        10. Derives personalizados
        11. Generación de código en build.rs
        12. Incluir archivos externos (include_str!, include_bytes!)
        13. cfg! y macros condicionales
        14. concat!, env!, option_env!
        15. Macros para FFI
        16. Macros para DSLs internos
        17. Macros para test parametrizado
        18. Macros para tracing de rendimiento
        19. quote y syn en procedural macros
        20. Límites de macros (higiene)
      5. Gestión de Recursos y RAII
        1. RAII (Resource Acquisition Is Initialization)
        2. Drop trait
        3. Cierre automático de archivos al salir de scope
        4. Liberación de locks al salir de scope
        5. MutexGuard y RwLockReadGuard
        6. ManuallyDrop<T>
        7. MaybeUninit<T>
        8. mem::forget
        9. Smart pointers con semántica RAII
        10. scopeguard (crates externos)
        11. Patrones de cleanup garantizado
        12. Evitar fugas de memoria no deseadas
        13. Control de recursos FFI
        14. Contadores de referencia (Rc, Arc)
        15. Descriptores de archivo y RAII
        16. Sockets y RAII
        17. Mutexes y RAII
        18. Buffers mmap y RAII
        19. Transacciones y RAII
        20. Tareas async abortables con RAII
      6. Monitoreo y Observabilidad
        1. tracing crate
        2. Spans y eventos
        3. #[instrument]
        4. Métricas de latencia
        5. Métricas de throughput
        6. Métricas de error rate
        7. Exportadores de métricas (Prometheus, etc.)
        8. Muestreo de eventos de alto volumen
        9. Logging estructurado en JSON
        10. Correlación de requests distribuidos
        11. Propagación de contexto en async
        12. Inicio y fin de span por request
        13. Identificadores de request
        14. Monitoreo de heap
        15. Monitoreo de file descriptors abiertos
        16. Monitoreo de latencia de syscalls
        17. Límites de memoria en contenedores
        18. Límites de CPU en contenedores
        19. Alertas y umbrales
        20. Integración con APM externos
      7. Gestión de Memoria y Bajo Nivel
        1. Ausencia de GC en Rust
        2. Propiedad y liberación determinista
        3. Stack vs heap
        4. Box<T> para heap
        5. Vec<T> como buffer dinámico
        6. String como buffer dinámico UTF-8
        7. Box<[T]> y slices en heap
        8. Box<dyn Trait>
        9. Pin<Box<T>>
        10. Pin<&mut T>
        11. Referencias crudas (*const T, *mut T)
        12. unsafe blocks
        13. unsafe fn
        14. extern "C"
        15. Layout de memoria con #[repr(C)]
        16. Acceso sin chequear a slices (get_unchecked)
        17. Eliminación manual de bounds checks
        18. Aliasing y &mut T
        19. Volátiles (ptr::read_volatile, ptr::write_volatile)
        20. MaybeUninit<T> para inicialización diferida
        21. Zero-cost abstractions
        22. Inlining y #[inline(always)]
        23. Eliminación de branching con match
        24. Control fino de panic = abort
        25. #![no_std]
        26. Usar core en entornos embebidos
        27. Arranque bare-metal (#[no_main])
        28. Interrupciones en microcontroladores (#[interrupt])
        29. Memoria compartida en ISR
        30. unsafe encapsulado en HALs embebidos
    7. Implementación y Distribución
      1. Herramientas Generales del Entorno
        1. rustup para toolchains
        2. cargo como orquestador
        3. rustc como compilador
        4. rustfmt para formato
        5. clippy para lints
        6. cargo audit para seguridad
        7. cargo deny para licencias
        8. cargo outdated para actualizar versiones
        9. cargo udeps para limpiar dependencias
        10. cargo tree para inspección de dependencias
        11. cargo metadata para tooling externo
        12. cargo watch para recarga en caliente
        13. just / make para automatización
        14. Scripts build.rs
        15. rust-toolchain.toml para fijar versión
        16. Cachés de compilación incremental
        17. Perfiles dev/release
        18. lto (link-time optimization)
        19. panic = abort para binarios pequeños
        20. strip de símbolos en binarios finales
        21. RUSTFLAGS personalizados
        22. Cross-compiling con --target
        23. cross (herramienta de cross-compiling)
        24. Integración con Docker
        25. Integración con Bazel / Buck (cuando aplica)
        26. Integración con Nix
        27. Integración con CI (GitHub Actions, etc.)
        28. Reproducibilidad binaria
        29. Firmas criptográficas de binarios
        30. Publicación interna de artefactos
      2. Compilación y Backends
        1. rustc
        2. MIR (Mid-level IR)
        3. LLVM IR
        4. Generación de código máquina
        5. Optimizaciones de LLVM
        6. -C opt-level
        7. -C target-cpu
        8. -C target-feature
        9. -C lto
        10. -C panic=abort
        11. -C relocation-model
        12. -C code-model
        13. -C inline-threshold
        14. -C link-args
        15. Compilación incremental
        16. Cache de incrustaciones (incr comp cache)
        17. Reutilización de artefactos en CI
        18. Compilación cruzada ARM / RISC-V
        19. WASM como objetivo (wasm32-unknown-unknown)
        20. wasm32-wasi
        21. Generación de librerías dinámicas (cdylib)
        22. Generación de librerías estáticas (staticlib)
        23. Binarios independientes (musl)
        24. Minimización de tamaño (opt-level = "z")
        25. Embedded no_std sin sistema operativo
        26. build-std para targets custom
        27. Xargo / cargo para compilación de core personalizada
        28. bindgen para generar bindings C
        29. cbindgen para exponer APIs C
        30. Versionado del compilador requerido (MSRV)
      3. Publicación y Versionado de Crates
        1. Cargo.toml con [package]
        2. name, version, edition
        3. authors / license
        4. readme
        5. repository
        6. documentation
        7. homepage
        8. keywords
        9. categories
        10. include / exclude
        11. features
        12. default-features
        13. optional = true
        14. cargo publish
        15. cargo yank
        16. SemVer para crates (MAJOR.MINOR.PATCH)
        17. breaking changes y bump mayor
        18. Compatibilidad semántica en librerías públicas
        19. Compatibilidad binaria de cdylib
        20. Versiones mínimas soportadas (MSRV en README)
        21. Changelogs y CHANGELOG.md
        22. cargo-release para automatizar versiones
        23. Firmar tags y releases
        24. Auditoría de licencias con cargo deny
        25. Auditoría de CVEs con cargo audit
        26. Políticas internas de seguridad
        27. Soporte de plataforma declarado (targets)
        28. Estados experimentales (unstable, nightly-only)
        29. Exponer #[cfg(feature = "foo")] en docs
        30. Estabilidad de APIs unsafe
      4. Aplicaciones CLI
        1. Crates clap, argh, structopt
        2. Parsing de argumentos
        3. Subcomandos
        4. Flags y opciones
        5. Validación de input
        6. --help y --version
        7. Autogeneración de ayuda
        8. Autocompletado de shell
        9. Colores y estilos (ansi_term, colored)
        10. Barras de progreso (indicatif)
        11. println! y salida estándar
        12. eprintln! y error estándar
        13. Códigos de salida (std::process::exit)
        14. Logging configurable por flag (-v, -q)
        15. Uso de anyhow o eyre en CLI
        16. Serialización de salida (serde_json)
        17. Interactivo en terminal (prompt)
        18. TUI (crossterm, ratatui)
        19. Tests de CLI vía assert_cmd
        20. Empaquetado estático
        21. Distribución en contenedores
        22. Binarios multiplataforma
        23. Firmas de binario y checksum
        24. Versionamiento semántico del binario
        25. Compatibilidad hacia atrás en flags CLI
        26. Integración con systemd / servicios
        27. Configuración vía archivos (toml, yaml)
        28. Variables de entorno (std::env)
        29. Actualización automática (self-update)
        30. Publicación en gestores de paquetes
      5. Aplicaciones Gráficas y de Escritorio
        1. egui
        2. iced
        3. gtk-rs
        4. winit
        5. Motores de juego (bevy)
        6. Renderizado con wgpu
        7. UIs nativas vs webview
        8. Empaquetado multiplataforma
        9. Integración con aceleración GPU
        10. Eventos y loop principal
        11. Recursos compartidos entre hilos UI
        12. Canales de comunicación UI ↔ lógica
        13. Serialización de estado UI
        14. Persistencia de preferencias
        15. Integración con sistemas de archivos
        16. Control de DPI y escalamiento
        17. Integración con backends audio
        18. Janelas múltiples
        19. Controladores de input (teclado, mouse, gamepad)
        20. Soporte de internacionalización en UI
        21. Empaquetado tipo instalador
        22. Firmado de binarios en macOS/Windows
        23. Sandboxing y permisos
        24. Notificaciones del sistema
        25. Integración con portapapeles
        26. Arrastrar y soltar
        27. Actualización auto-generada (autoupdater)
        28. Integración con WebAssembly para componentes
        29. Reutilización de lógica Rust en frontend web
        30. Herramientas de depuración visual
      6. Internacionalización (i18n) y Localización (l10n)
        1. Soporte de Unicode en String
        2. Formato localizado de números y fechas (crates externos)
        3. Carga de catálogos de traducción
        4. Selección dinámica de idioma
        5. Separación de recursos por locale
        6. Plantillas de mensajes parametrizados
        7. Integración de i18n en CLI
        8. Integración de i18n en GUI
        9. Internacionalización en aplicaciones web (axum, actix)
        10. Mensajes de error traducibles
        11. Recursos de texto estáticos empaquetados (include_str!)
        12. Detección de locale del sistema
        13. Pluralización y reglas gramaticales
        14. Formato de monedas y unidades
        15. Localización offline en binarios estáticos
        16. Actualización de catálogos sin recompilar
        17. no_std y mensajería mínima
        18. i18n en firmware embebido (pantallas pequeñas)
        19. Soporte RTL (right-to-left)
        20. Compatibilidad con estándares gettext
        21. Convenciones culturales en fechas/hora
        22. Adaptación de layouts UI a idiomas
        23. Internacionalización de documentación pública
        24. Mantenimiento de catálogos en repositorios
        25. Tests que validan traducciones
        26. Versionado de recursos lingüísticos
        27. Seguridad frente a inyección en plantillas traducibles
        28. Selección de idioma vía variables de entorno
        29. Fallbacks de idioma
        30. Integración con pipelines de CI para i18n
    8. Internals
      1. Compilador de Rust (rustc)
        1. Fases del compilador
        2. Parseo del código fuente
        3. Árvore de sintaxis (AST)
        4. AST desugaring
        5. HIR (High-level IR)
        6. MIR (Mid-level IR)
        7. Borrow checker
        8. Inferencia de lifetimes
        9. Resolución de tipos
        10. Monomorfización de genéricos
        11. Optimización en MIR
        12. Traducción a LLVM IR
        13. Optimizaciones de LLVM
        14. Generación de código máquina final
        15. Enlazado (linking)
        16. rustc --emit
        17. rustc --emit=mir (nightly)
        18. rustc --emit=llvm-ir
        19. rustc --emit=asm
        20. Control de lint con #![deny], #![warn]
        21. #[inline] y sugerencias de optimización
        22. #[cold] para rutas raras
        23. #[must_use] para resultados críticos
        24. #[repr(C)] para FFI estable
        25. #[no_mangle] para símbolos exportados
        26. #[link(name = "...")]
        27. Driver de compilación en cargo
        28. Caches de compilación incremental
        29. Hashes de contenido para recompilación selectiva
        30. Flags de depuración y symbols (-g)
      2. Modelo de Ejecución
        1. Binarios nativos
        2. Librerías dinámicas (cdylib)
        3. Librerías estáticas (staticlib)
        4. Binarios estáticos (musl)
        5. WASM (wasm32-unknown-unknown)
        6. WASI (wasm32-wasi)
        7. no_std en entornos bare-metal
        8. #[no_main] para runtime propio
        9. Punto de entrada fn main()
        10. panic! como abort o unwind
        11. panic = abort en Cargo.toml
        12. panic = unwind
        13. Stack unwinding y catch_unwind
        14. Manejadores panic::set_hook
        15. Inicialización estática
        16. Orden de static init
        17. Finalización a través de Drop
        18. RAII para cleanup determinista
        19. Drop en cascada
        20. Threads del sistema operativo (std::thread)
        21. Futures y ejecutores async en espacio de usuario
        22. Pools de hilos vs loops event-driven
        23. Bloqueo vs no-bloqueo en I/O
        24. Programación lock-free
        25. Exclusión mutua con Mutex
        26. RwLock para acceso paralelo de solo lectura
        27. Atomics y órdenes de memoria
        28. Volátil para MMIO
        29. Interacciones con señales del SO
        30. Integración con FFI de C en runtime
      3. Modelo de Datos
        1. Representación en memoria de structs
        2. #[repr(Rust)] por defecto
        3. #[repr(C)] para compatibilidad ABI con C
        4. #[repr(packed)]
        5. #[repr(transparent)]
        6. Orden y alineación de campos
        7. Enum layout optimizado (Option<&T> sin overhead)
        8. Nichos de valores no usados (niche optimization)
        9. Box<T> como puntero único a heap
        10. Rc<T> con conteo de referencias single-thread
        11. Arc<T> con conteo de referencias thread-safe
        12. Cell<T> y RefCell<T> para mutabilidad interior
        13. UnsafeCell<T> como primitiva base de interior mutability
        14. Zonas exclusivas de referencia mutable (&mut T)
        15. Reglas de aliasing en borrow checker
        16. Send para traspaso seguro entre hilos
        17. Sync para acceso compartido seguro
        18. Unpin y movimiento seguro de futures
        19. Pin<&mut T>
        20. MaybeUninit<T> para inicialización manual
        21. ManuallyDrop<T> para controlar Drop
        22. Propiedad lineal como contrato estático
        23. Ciclos de referencia con Rc
        24. Weak<T> para romper ciclos
        25. Fugas de memoria intencionales (leak)
        26. Layout de closures y capturas
        27. dyn Trait y fat pointers (puntero + vtable)
        28. Llamadas virtuales vía vtable
        29. #[inline] y monomorfización en genéricos
        30. Eliminación de código muerto en monomorfización
      4. Modelo C y FFI
        1. extern "C" en funciones
        2. #[no_mangle] para nombres estables
        3. #[repr(C)] en structs para FFI
        4. Punteros crudos (*const T, *mut T)
        5. unsafe en llamadas FFI
        6. Traducción de enum a C
        7. Strings CString
        8. CStr
        9. Buffers *mut u8
        10. Longitud y ownership cruzando la frontera FFI
        11. Callbacks desde C hacia Rust
        12. Callbacks de Rust hacia C
        13. ABI estable entre Rust y C
        14. ABI entre Rust y C++
        15. bindgen para generar bindings desde headers C
        16. cbindgen para exponer headers C desde Rust
        17. Reglas de seguridad al exponer punteros
        18. Gestión de memoria compartida con librerías C
        19. #[link(name = "...")]
        20. #[link(kind = "static")]
        21. #[link(kind = "dylib")]
        22. Cargar librerías dinámicas en runtime
        23. Paso de structs complejos a C
        24. Paso de callbacks con extern "C" fn
        25. Manejo de errores en FFI (errno, códigos de error)
        26. Invariantes documentadas en funciones unsafe
        27. Pruebas de integración con librerías C existentes
        28. Construcción cruzada para plataformas embebidas
        29. Integración con kernels / drivers
        30. no_std y FFI en firmware
      5. Extensiones y Casos Especiales
        1. no_std y entornos sin sistema operativo
        2. Sistemas embebidos ARM Cortex-M
        3. RISC-V embebido
        4. Mapeo de registros de hardware con volatile
        5. Interrupciones (#[interrupt])
        6. Bootloaders en Rust
        7. Sistemas operativos escritos en Rust
        8. Kernels monolíticos vs microkernels en Rust
        9. Drivers de dispositivo en Rust
        10. Controladores de red en Rust
        11. Librerías criptográficas sin std
        12. Criptografía con no_std
        13. Randomness seguro (rand_core)
        14. #![forbid(unsafe_code)] en capas superiores
        15. unsafe encapsulado en HALs
        16. WebAssembly (wasm32-unknown-unknown)
        17. WASI (wasm32-wasi)
        18. Llamadas host ↔ WASM
        19. Limitaciones de asignador en WASM
        20. Serialización compacta para WASM
        21. Portado de lógica Rust a frontend web
        22. Reutilización de core logic en CLI y servidor
        23. Reutilización de lógica en microcontroladores
        24. Estrategias para panic en entornos sin stdout
        25. panic-halt y panic-abort
        26. Arranque seguro y watchdog
        27. Integridad de memoria en dispositivos críticos
        28. Certificación de software seguro
        29. Política de revisiones de unsafe
        30. Evolución futura del lenguaje, del borrow checker y de async nativo