While that is true, taking an initial look at the rust tutorial it seems to me that the number of syntactic rules in the language for Rust are much more than in Go, which is always a negative sign.
True, Rust has more syntactic rules than Go, but it's still (in my mind) a very small language, especially compared to C++. The developers are very conscious of language complexity and will not introduce new concepts spuriously. The increased complexity is because they're aiming Rust at a different application domain than Go, and for that application domain they feel that programmers require more fine-grained control.
Every language is small compared to C++. And keep in mind that Rust is still very young, and if simplicity is not a goal complexity can skyrocket before Rust reach 1.0 state.
However, the devs are aiming to keep the language simple. They're PL experts (watching them at work is quite intimidating, actually, as someone who doesn't have a PhD in CS), but they absolutely reject the allure of the ivory tower. Note the header on the page linked in this submission:
"a safe, concurrent, practical language"
Note "practical". I've witnessed several exchanges on the mailing list where the developers attempt to excise language features. For example, in Rust, `if` is an expression rather than a statement, and thus is redundant with the `?:` ternary conditional expression syntax familiar to C-like languages (the latter was removed). Alternatively, they often acknowledge that having three types of pointers is suboptimal from a simplicity perspective, but they consistently conclude that the semantics unique to each type of pointer are valuable enough to justify the mental cost.
Simplicity is definitely a goal. These days, not a day goes by on the Rust team in which we don't discuss ways to simplify the language.
My colleague Dave Herman always says that language design goes through cycles: You identify a problem, add solutions to fix it, then discover that these solutions are best merged with some other ideas. The result is that, as a language evolves, complexity goes up and down. I think that we're coming off a peak of complexity and the language is going to evolve toward simplicity in the near term.
Just to name a few simple examples, removing the alias analysis pass and removing "native modules" are some simplifications that mostly have consensus at this point.
