Great things about Rust that aren't just performance

Original Article ↗ Hacker News Discussion ↗

Rust’s appeal for many engineers goes well beyond raw speed, centering on strong compile-time guarantees, a powerful type and trait system, exhaustive pattern matching, and tooling like Cargo and rustdoc that make refactoring and dependency management unusually safe and ergonomic. Commenters contrast these strengths with weaknesses they see in C, C++, Go, and dynamic languages—such as null handling, exception-driven error models, and fragile refactors—while also noting Rust’s trade‑offs: steep learning curve, slow compile times, complex async story, and gaps in higher-level web frameworks compared to ecosystems like Django or Rails. There is broad agreement that Rust enables more “fearless” maintenance and concurrency, but skepticism about overzealous evangelism and about how well it fits domains where rapid iteration or garbage-collected languages already work well.

Language design & expressiveness

  • Many praise Rust as a “bag of sensible defaults”: move-by-default, immutable-by-default, exhaustive match, integrated testing, and strong enums + pattern matching.
  • Traits (inspired by Haskell type classes more than OOP interfaces) are seen as a major win over deep inheritance hierarchies.
  • Some dislike move-by-default ergonomics, but others argue it prevents C++-style lifetime bugs and forces clear ownership.
  • Implicit returns from the last expression in a block divide opinion; some see them as coherent with “everything is an expression,” others prefer explicit return.

Type system, safety, and error handling

  • The borrow checker and ownership model are repeatedly cited as the headline feature, enabling fearless refactoring and strong guarantees without huge test suites.
  • Option/Result-style error handling is preferred by many over C++ exceptions, though there’s debate:
    • Critics note that plain ?-based flows lack stack traces or context unless extra libraries (e.g., anyhow) or backtraces are used.
    • Pro-exception voices emphasize automatic stack traces and richer diagnostic info; others respond that RAII and explicit error types avoid exception footguns.
  • Rust does not prevent memory leaks; commenters distinguish “memory safety” (no UAF, double free, data races) from leaks, which remain possible and occur in real Rust projects.

Tooling, ecosystem, and dependencies

  • Cargo, rustdoc, consistent formatting, and strong diagnostics are widely admired; some compare favorably against C++ build tooling and Go’s documentation tools.
  • Crate explosion (hundreds of transitive deps) worries some, invoking npm comparisons; others argue Rust’s ecosystem learned from npm’s mistakes and that microcrates centralize auditing.
  • Docs.rs’s own large dependency tree is noted as a service concern rather than a language one.

Concurrency & smart pointers

  • Rust’s Send/Sync traits, Arc, Mutex, and move semantics enforce that you can’t get unsynchronized mutable access from multiple threads in safe code.
  • Discussion clarifies that Mutex itself doesn’t add pointer indirection; Arc does due to heap allocation.

Use cases, performance, and DX

  • Many use Rust for systems, data processing (e.g., Polars), and performance-critical components; some find web backends and async Rust ergonomically weak and slow to compile.
  • Others prefer higher-level languages (Kotlin, C#, TypeScript, Python+type checkers) for general app development, citing faster iteration, GC, or richer IDE support.
  • Several emphasize that Rust reduces but does not eliminate the need for tests; some see compile-time errors as “ultra-fast unit tests.”

Community & culture

  • Enthusiasm for Rust is strong, but some perceive parts of the community as overzealous or dogmatic.
  • Overall sentiment: Rust is not perfect or universal, but its safety guarantees, refactorability, and tooling make its trade-offs attractive for many domains.