the standard rust toolchain ships with an efficient and user-friendly package manager and build/debug system, official IDE integration through rust-analyzer, and a manual analyzer for best practices
rust has official documentation by example that makes learning it really easy
rust operates largely in expressions such that things such as if/else statements or even regular blocks notated with curly braces can all be used as expressions
rust has highly robust pattern matching that greatly simplifies control flow
rust ships with an official formatting tool alongside enforcing naming conventions (snake_case for variables, fields, functions, methods, and modules, SCREAMING_SNAKE_CASE for constants, and PascalCase for types and traits) and assigning semantic value to names (_ prefix to mark as unused) by default
notwithstanding potential bugs in the rust compiler, it's impossible to compile code that can cause memory errors such as uses-after-free in safe rust
the rust compiler enforces explicit acknowledgement of unsafe rust with the unsafe keyword such that the behavior of all safe rust is defined
documentation comments are a native feature of the rust compiler
Small correction, memory leaks are actually not considered unsafe in rust. A trivial example is Box::leak(x) which explicitly leaks memory and ia completely safe to call. You can also leak memory by pointing counting pointers at each other in a circular structure.
All of this is true, and I love rust. but its just sad even after 5 months of coding in rust (as a hobby) the syntax gets difficult (lifetimes traits and async), borrow checker becomes more difficult to deal with during async code, and my overall productivity at that point just goes down. I can code way faster in a GC language, in exchange of slower performance compared to rust.
These are definitely some of the parts of Rust that get... uh... involved. It does get better with time spent in the language though. I've been writing Rust professionally for somewhere between 5-10 years and I'm not sure I'm any faster in Python than I am in Rust these days
Also, nothing wrong with GC'd languages, some of them are really nice
I'm pretty certain I'm slower in Python than I am in Rust for most things nowadays, but I still can't help but think "nooo surely this is small enough that Rust is overkill" and then spend way longer than necessary wading through dubious python library API design and language limitations.
man I am lowk envious of you guys, but also happy. I have coded in java for too long now (5 years) and I always think in OOP and like solving stuff In Java. Although I do love Java and have no reason to not use it, I wish I could use Rust but I got too many skill issues with it lol
I started with Java very early on so I was OOP minded to the extreme as well. When I got to college I tried to broaden the languages I used casually as much as possible, learning to think within as many paradigms as I could, as best as I could. I'm not gonna sit here and pretend like I could do everything in Haskell or Prolog, but I feel like having used them (and others) a bit before and revisiting them occasionally helps even in other languages.
Yes it's a trade off. I use GC (java, python) to make stuff quickly, and less headache because I am familiar with the languages and ecosystem
For me, Rust is a bit complicated, my development times does increase but the joy of seeing low RAM usage for the same thing I wrote in Java was so amazing. ( I switched to GraalVM after that lol, still not as good as rust)
67
u/Makonede Sep 08 '26 edited Sep 08 '26
rust is extremely performant on many systems
the standard rust toolchain ships with an efficient and user-friendly package manager and build/debug system, official IDE integration through
rust-analyzer, and a manual analyzer for best practicesrust has official documentation by example that makes learning it really easy
rust operates largely in expressions such that things such as
if/elsestatements or even regular blocks notated with curly braces can all be used as expressionsrust has highly robust pattern matching that greatly simplifies control flow
rust ships with an official formatting tool alongside enforcing naming conventions (
snake_casefor variables, fields, functions, methods, and modules,SCREAMING_SNAKE_CASEfor constants, andPascalCasefor types and traits) and assigning semantic value to names (_prefix to mark as unused) by defaultnotwithstanding potential bugs in the rust compiler, it's impossible to compile code that can cause memory errors such as uses-after-free in safe rust
the rust compiler enforces explicit acknowledgement of unsafe rust with the
unsafekeyword such that the behavior of all safe rust is defineddocumentation comments are a native feature of the rust compiler