Rust 1.100

Rust 1.100 is received as a landmark release, highlighted by long-awaited features like stabilization of the “never” type, custom allocators, dependency cooldowns for supply-chain safety, and Cargo improvements such as unused-dependency warnings and safer `cargo install` behavior. Commenters debate the tradeoffs between security and agility in dependency management, the long-running question of a stable Rust ABI for dynamic linking and OS packaging, and ongoing frustrations with compile times and disk usage. Several posts also note how Rust’s strong type system and tooling pair especially well with LLM-based coding agents, potentially shifting how its steep learning curve is perceived.

Overall reaction to Rust 1.100

  • Many commenters see 1.100 as a “monumental” / “huge” release with a lot of long‑running work finally landing.
  • Strong appreciation for maintainers and contributors; some note how consistent the 6‑week release cadence has been through 100 releases.

Language & stdlib features (never type, DropGuard, misc APIs)

  • Stabilization of the never type ! is widely celebrated; jokes about “never finally happening” and long‑running memes expiring.
  • Several explanations: ! as an uninhabited/bottom type, used for diverging control flow, and now usable inside types like Result<T, !>.
  • DropGuard is compared to Go’s defer, but with the ability to “dismiss” it; seen as useful for “do this unless successful” patterns.
  • Smaller APIs like bool::toggle, Box::map, and trim_prefix/trim_suffix on strings/paths generate discussion:
    • Some find toggle() clearer for long access chains; others see it as redundant vs x = !x or ^= true.
    • Performance concerns are dismissed as optimizable/inlinable.

Cargo, dependencies, and security (cooldowns, install, unused deps, min-publish-age)

  • Custom allocators and minimum publish age (“dependency cooldowns”) are highlighted as favorites.
  • Cooldowns spark debate:
    • Pro: Mitigate supply‑chain attacks by delaying adoption of fresh releases.
    • Concerns: May delay 0‑day fixes; hard to cleanly distinguish “security advisory” updates from normal ones.
  • cargo install now using crate lockfiles by default is praised; earlier behavior was seen as dangerous/unintuitive.
  • New unused_dependencies lint is welcomed; some note it pairs well with agents that auto‑fix warnings.
  • Min‑publish‑age is criticized as bypassable by time‑bomb malware; others argue it still adds real friction and is complemented by third‑party scanning.

Stable ABI and dynamic linking

  • Large thread on the lack of a native stable Rust ABI:
    • Pro‑ABI: Easier OS‑level library updates, smaller binaries, less recompilation, better cross‑language interop, potential ecosystem gains (e.g., error/result types across languages).
    • Skeptical: Generics and lifetimes make a fully stable ABI hard; concern about long‑term constraints similar to C++.
  • Current stance described as:
    • Rust already has a stable C ABI (extern "C"), plus possible future opt‑in Rust ABIs (e.g., crABI).
    • Any practical stable ABI will be a subset of the language, likely dyn‑trait/slice–oriented at first.
  • Some argue dynamic linking and ABI stability would also help compile times and target‑dir bloat.

Compile times, disk usage, and tooling

  • Many complaints about slow compilation and huge target directories (dozens to hundreds of GB in extreme anecdotes).
  • Others counter that:
    • Rust has been getting faster over time; there’s ongoing dedicated work (parallelization, build‑dir GC, deduplication, relink‑don’t‑rebuild).
    • Compared to large C++ builds, Rust is already “pretty fast,” especially incrementally.
  • Suggested mitigations: reduced debug info, better build scripts, splitting dependencies into dynamic libraries, and using profiling tools (--timings, measure‑type tools).

Rust, AI agents, and development style

  • Several comments describe Rust as especially good for LLM/agent workflows:
    • Strong type system and strict compiler give agents clear, actionable feedback.
    • Turning on many lints and treating warnings as blocking lets agents iteratively fix code and remove unused deps.
  • Some question whether human‑facing language features still matter “in the age of LLMs”; others push back, emphasizing durability and human intelligibility for non‑throwaway code.
  • Rust is portrayed as particularly attractive in AI‑assisted workflows because traditional human pain points (borrow checker, strictness) are less problematic for agents.

Versioning, editions, and breaking changes

  • A minor breaking change (type inference around Infallible) prompts questions about semver:
    • Respondents point to Rust’s documented “stability caveats” (bug fixes, safety fixes, inference tweaks allowed) and edition system.
    • Editions let crates opt into breaking language changes while keeping cross‑edition interoperability; hence no “2.0” yet.

Language choice and Rust vs C/C++

  • Some discussion on whether to learn C, C++, or Rust:
    • Rust is recommended for safety and modern tooling; C seen as simpler but unsafe; C++ as powerful but extremely complex.
  • Debate on whether Rust is “gaining territory” over C++ remains inconclusive in the thread.