Great things about Rust that aren't just performance

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.