I Hope Rust Does Not Oxidize Everything

Original Article ↗ Hacker News Discussion ↗

Role of Rust vs Other Languages

  • Many see Rust as a major step up from C/C++ for safety while retaining low-level control, especially for security-critical / systems work.
  • Others argue it’s only a big improvement for some domains; embedded and interop-heavy work still often favor C/C++.
  • GC languages (OCaml, .NET, Java, Go, Elixir/BEAM) are viewed as fine for most apps, but unsuitable where predictable latency, small runtimes, or single-GC constraints matter.
  • Several commenters lament that ML-style safety could have been mainstream earlier (e.g., OCaml) if not for GC and unfamiliar syntax.

Interop, Ecosystems, and “NIH”

  • Some claim Rust is harder to reuse C libraries in without dropping into unsafe, which they see as negating Rust’s benefits and encouraging “rewrite in Rust.”
  • Others counter that Rust was designed for C FFI, that most Rust code already relies on small unsafe islands (including stdlib), and that mature safe wrappers exist for many C libraries.

Async, Executors, and Runtime Design

  • Async Rust is a frequent pain point: multiple incompatible executors (Tokio, etc.), difficulty composing async and sync APIs, and “async infecting everything.”
  • Some suggest adding a minimal executor or pollster-like tool to std; others point to ongoing work (e.g., keyword generics) to unify sync/async patterns.
  • Comparisons are made to GC/runtime fragmentation and to other ecosystems where both sync and async APIs are common.

Syntax, Complexity, Readability

  • Complaints focus on sigil-heavy, dense syntax (lifetimes, generics, ::, closures, “turbofish”) and complex function signatures.
  • Supporters argue this trades aesthetics for explicitness, C++ familiarity, and “grep-ability,” and that difficulty is more about concepts than symbols.
  • Some see a “smaller, simpler, safer language” hiding inside Rust (often “Rust without async”); others point to alternative designs (Yao, Austral, Zig).

Compile Times and Developer Experience

  • Slow compilation is widely acknowledged; large projects, macros, and monomorphization are blamed.
  • Some prioritize fast edit-compile-run loops and consider Rust’s latency unacceptable compared to C, Zig, or Lisps with fast compilers/JITs.
  • Others accept slower builds in exchange for stronger static checking and rely on cargo check and incremental builds.

Adoption, Monoculture, and Ecosystem

  • Several argue Rust breaks an old C/C++ “monoculture” by inspiring new systems languages (Zig, Odin, Vale, etc.), making a Rust monoculture unlikely.
  • Others see parallels to C++: growing complexity, long compile times, async/runtime issues, and predict C and C++ will remain widely used.
  • Some worry about parts of the Rust community being defensive about bootstrapping, specs, or alternative compilers.