Rust 1.100

Rust 1.100 se recibe como una versión histórica, destacada por funciones largamente esperadas como la estabilización del tipo “never”, allocators personalizados, cooldowns de dependencias para la seguridad de la cadena de suministro y mejoras de Cargo como advertencias sobre dependencias no usadas y un comportamiento más seguro de `cargo install`. Los comentaristas debaten los compromisos entre seguridad y agilidad en la gestión de dependencias, la cuestión de largo recorrido de una ABI estable de Rust para enlace dinámico y empaquetado a nivel del SO, y las frustraciones persistentes con los tiempos de compilación y el uso de disco. Varios mensajes también señalan cómo el sistema de tipos fuerte y las herramientas de Rust encajan especialmente bien con agentes de codificación basados en LLM, lo que podría cambiar la percepción de su curva de aprendizaje pronunciada.

Reacción general a Rust 1.100

  • Muchos comentaristas ven 1.100 como una versión “monumental” / “enorme” con mucho trabajo de larga data que finalmente llega.
  • Gran aprecio por los mantenedores y colaboradores; algunos señalan lo consistente que ha sido el ritmo de lanzamientos de 6 semanas a lo largo de 100 versiones.

Funciones del lenguaje y de la stdlib (never type, DropGuard, APIs varias)

  • La estabilización del never type ! se celebra ampliamente; hay bromas sobre que “never” finalmente ocurra y memes de larga duración que expiran.
  • Varias explicaciones: ! como un tipo inhabitable/de fondo, usado para el flujo de control divergente, y ahora utilizable dentro de tipos como Result<T, !>.
  • DropGuard se compara con defer de Go, pero con la capacidad de “dismiss” (descartarlo); se considera útil para patrones de “haz esto a menos que tenga éxito”.
  • APIs más pequeñas como bool::toggle, Box::map y trim_prefix/trim_suffix en cadenas/rutas generan discusión:
    • Algunos encuentran toggle() más claro para cadenas largas de acceso; otros lo ven redundante frente a x = !x o ^= true.
    • Las preocupaciones de rendimiento se descartan porque se puede optimizar / inlinear.

Cargo, dependencias y seguridad (cooldowns, install, dependencias no usadas, min-publish-age)

  • Los allocators personalizados y la edad mínima de publicación (“dependency cooldowns”) se destacan como favoritos.
  • Los cooldowns generan debate:
    • Pro: Mitigan ataques a la cadena de suministro al retrasar la adopción de lanzamientos recientes.
    • Preocupaciones: Pueden retrasar correcciones de día cero; es difícil distinguir limpiamente actualizaciones de “security advisory” de las normales.
  • Se elogia que cargo install use ahora por defecto los lockfiles de los crates; el comportamiento anterior se veía como peligroso / poco intuitivo.
  • El nuevo lint unused_dependencies es bien recibido; algunos señalan que encaja bien con agentes que corrigen advertencias automáticamente.
  • La min-publish-age se critica por ser eludible mediante malware de temporizador; otros argumentan que aun así añade fricción real y se complementa con escaneo de terceros.

ABI estable y enlace dinámico

  • Gran hilo sobre la falta de una ABI nativa estable de Rust:
    • A favor de la ABI: Actualizaciones de bibliotecas a nivel del SO más fáciles, binarios más pequeños, menos recompilación, mejor interoperabilidad entre lenguajes, posibles beneficios para el ecosistema (p. ej., tipos de error / resultado entre lenguajes).
    • Escépticos: Los genéricos y los lifetimes hacen difícil una ABI totalmente estable; preocupa imponer restricciones a largo plazo similares a C++.
  • La postura actual se describe como:
    • Rust ya tiene una ABI C estable (extern "C"), además de posibles futuras ABI de Rust opcionales (p. ej., crABI).
    • Cualquier ABI estable práctica será un subconjunto del lenguaje, probablemente orientada primero a dyn-trait / slices.
  • Algunos sostienen que el enlace dinámico y la estabilidad de la ABI también ayudarían a los tiempos de compilación y al crecimiento de target/.

Tiempos de compilación, uso de disco y herramientas

  • Muchas quejas sobre compilación lenta y enormes directorios target (de decenas a cientos de GB en anécdotas extremas).
  • Otros responden que:
    • Rust ha ido mejorando su velocidad con el tiempo; hay trabajo dedicado en curso (paralelización, GC del directorio de build, deduplicación, relink-no-rebuild).
    • Comparado con grandes compilaciones de C++, Rust ya es “bastante rápido”, especialmente de forma incremental.
  • Mitigaciones sugeridas: menos información de depuración, mejores scripts de build, dividir dependencias en bibliotecas dinámicas y usar herramientas de profiling (--timings, herramientas de medición).

Rust, agentes de IA y estilo de desarrollo

  • Varios comentarios describen Rust como especialmente bueno para flujos de trabajo con LLM/agentes:
    • El sistema de tipos fuerte y el compilador estricto dan a los agentes retroalimentación clara y accionable.
    • Activar muchos lints y tratar las advertencias como bloqueantes permite que los agentes corrijan el código iterativamente y eliminen dependencias no usadas.
  • Algunos cuestionan si las características orientadas a humanos siguen importando “en la era de los LLM”; otros responden enfatizando la durabilidad y la inteligibilidad humana para código que no es desechable.
  • Rust se retrata como particularmente atractivo en flujos asistidos por IA porque los puntos de dolor tradicionales para humanos (borrow checker, rigor) son menos problemáticos para los agentes.

Versionado, ediciones y cambios rompientes

  • Un cambio rompiente menor (inferencias de tipos alrededor de Infallible) plantea preguntas sobre semver:
    • Los respondientes señalan las “stability caveats” documentadas de Rust (se permiten correcciones de bugs, fixes de seguridad y ajustes de inferencia) y el sistema de ediciones.
    • Las ediciones permiten que los crates adopten cambios rompientes del lenguaje mientras mantienen la interoperabilidad entre ediciones; por eso aún no hay un “2.0”.

Elección de lenguaje y Rust vs C/C++

  • Hay debate sobre si aprender C, C++ o Rust:
    • Se recomienda Rust por seguridad y tooling moderno; C se ve como más simple pero inseguro; C++ como potente pero extremadamente complejo.
  • El debate sobre si Rust está “ganando terreno” frente a C++ sigue inconcluso en el hilo.