1. The features tend to be intuitive to use, and work in the way you expect them to. 2. If you do make a mistake, this tends to be a compile time error with a helpful error message that explains what you've done wrong. 3. The most complicated features are rarely used. Most of my Rust reads like TypeScript.
Part of the problem with C++'s complexity is not only is it difficult to work out the correct incantation, but it's difficult to know whether you have or not. Rust almost completely takes away that uncertainty.
The compile times are definitely an issue unfortunately.
I personally subscribe to the "waterbed theory of complexity", that is, I believe that the world is complex, and often, attempts to remove complexity cause it to pop up somewhere else. Rust's goals have an inherent level of complexity to them, and so require a certain degree of complexity to accomplish. There is an argument that if we had dropped one or two of those goals, we could have made a language that is much simpler, but I'm also not sure Rust would be as popular if we did.
One thing we strive for with Rust is that features are reasonably orthogonal and work well together, without weird corner cases. We also try to only add more features when the cost is actually justified. We have said "no" to a lot of things. We have also tried and rejected a lot of things.
You also may enjoy this blog post of mine: https://words.steveklabnik.com/the-language-strangeness-budg...
(I should also note that I'm not actually on the lang team, so this is more of a statement about what I observe and my own opinion rather than policy, strictly speaking.)
Yes, but sometimes the average brain is better at dealing with certain types of complexity. C++, IMO, puts the complexity in the wrong places. Programming is inherently complex, but it shouldn't be any more so than it needs to be and the complexity should be of the type humans can manage, as much as possible anyway.
You're right that it isn't a "simple" language (in the Rich Hickey sense of the word). And I don't think there's any effort to actively simplify it.
However, I do expect the rate of complexity growth to taper off fairly soon. Every feature that gets added to Rust is added carefully and with a clear vision in mind. Up until now they've still been building out the foundations of what most people will need when using Rust in different contexts. Recently a lot of this has been ergonomics (like async/await). But I think the rate of features being added is an S-curve, and I think we're nearing the top. Given that, I have hope that it won't follow the same path as C++ in terms of sprawl; it's certainly not as complicated as C++ yet, and if it doesn't keep growing at this rate, I don't think it will become that way.
Part of why C++ is so complicated is that it's had to tack-on decades of language advancements, after the fact, as they were invented/became prevalent. Heck, C++ itself is already a tack-on of C. There wasn't a clear initial vision for the past couple decades of "stuff".
Rust, on the other hand, a) has those decades of ideas to incorporate from the outset in a cohesive way, and b) was started from scratch, not an extension of an existing language. This has so far meant a much clearer sense of vision and big-picture design. These features were made to work together; the roadmap was fairly clear from the beginning.
But the borrow checker is an interesting case because simplifying its rules in such a way that they're more tolerant (without sacrificing safety) might reduce cognitive overhead while still being fully backwards-compatible.
There is a fine balance here, for example: https://news.ycombinator.com/item?id=22465409
Actually, I was trying to explain this a few days ago: https://users.rust-lang.org/t/any-possible-improvements-to-t...
Rust has an Iterator type. It might be a bit "complex" to understand at first sight, but once you grasp the concept, it makes programming much easier. And your code is much more readable too. I try to avoid loops/conditionals these days; if I'm using them, I probably can express that in a Type and have a descriptive name/functions for that type.
There are many more types/syntax that makes programming with Rust a marvel: Result/Option types, generics, macros, async/await, error chaining, etc...
It's also pretty different to what most people are used to. I found it a approach to polymorphism refreshing, coming from Haskell, but that's not a typical pathway. The average Java dev will need some time to get used to how extensive generics are in the language.
As someone who doesn't really use Rust, does anyone who does find the complexity detracts from it a bit as a language? Is there effort to reduce complexity with the language or does it mostly embrace it?
At this point I find myself mostly looking at modern C alternatives—ones which manage to stay relatively simple the way C does, but with a few additional features and better designs (Zig, Odin, maybe Jai, etc).
All that said, I work with C++ and so I could see myself potentially working with Rust in the future, so I'm curious how people feel about its complexity, especially given that its complexity will presumably only increase with time.