Rust

  28 minutos de lectura  

  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
Última modificación October 26, 2025: Changes (6094d13)