I love how it deals with memory management without the need for a
Garbage Collector.
I love its strictness. The compiler throws errors on every little
detail, which is great. It doesn't try to make the programmer happy, it
just is strict and correct. This eliminates some error classes.
(To be fair, *every* compiler should behave that way. Why do we have to
use so many flags to turn on all those warnings in C compilers? How is
that not the default? Because of old code? Well, why not introduce a
flag like `--this-is-old-code-so-please-compile-it-anyway`?)
On the other hand, Rust is full of features. If find it really hard to
read Rust code. It's like a C preprocessor on steroids. And of course,
people use them all. It takes a lot of discipline to write good, clean,
and easy to read code in *any* language -- but the more features a
language has to offer, the harder it gets. Macros make everything worse.
Oh and everyone uses type inference all the time. Well, of course they
do, it's so much easier, isn't it? Yeah, sad thing is, this kills one
very positive aspect of a statically typed language: Being easy to
follow. Reading Rust code feels like reading Python code in that
regard:
let foo = function_call();
Thanks for nothing, you lazy bastard. :)
let foo: i32 = function_call();
Aha! We're dealing with an `i32`. No need to jump around in the code or
to ask your IDE or to read any docs. It says it right there. `i32`.
Rust code tends to be very "expressive". (I don't know if that's the
proper translation. The german word for this is "ausdrucksstark".) A lot
of meaning crammed into just a few bytes. This makes for shorter code,
but demands more brain capacity and brain power from the reader.
Of course, it's just me being inexperienced and, in time, I'll learn to
deal with it. That's why I want to continue learning Rust. I have high
hopes. I also acknowledge that Rust is very young and things might
change for the better. For example, there is no random number generator
in the core library -- yet.
