Sort by

That was a good one, Tim. Thanks a lot for it.

Can you link to the questions or the page where these top-rated questions are listed?

As to the aliasing in Rust, LLVM12 supposedly fixed most if not all of these issues, so maybe we could have this noalias applied later this year? (hopeful thinking)

What you said about strings isn't entirely accurate.

fn greet(name: &str) { println!("Hey!, {}", name); } Will accept both String and &str as a parameter without the need for a call to AsRef<str> as such:

fn main() { let jesus = String::from("Jesus"); let dave = "Dave"; greet(&jesus); // Note that you have to borrow a 'String' greet(dave); //Note that you don't have to borrow explicitly here }

Also, I strongly recommend (in fact I'd even go as far as to say) that you don't allocate Strings willy nilly just because. Rust is a systems language and, I'd argue, you are learning it or are interested in it because you want to make performant software, and String allocations (and Vectors, and Box, and HashMaps, etc.) are expensive and should be used with care, unless of course you don't care about performance or memory usage like this: fn greet<T: Into<String>>(name: T) { println!("Hey!, {}", name.into()); // potentially very expensive copy and allocation of data!!! Warning!!! } Or: fn greet<T: ToString>(name: T) { println!("Hey, {}", name.to_string()); // warning!!! The same as above!! } Cloning heap objects should not be your go to when writing software that's supposed to be performant, but as a beginner learning Rust I guess it's okay, but you should never reach for cloning objects unless absoultely necessary. In fact, I'd even say, that if you're cloning a lot in your codebase then you should try to see if there's a better way to structure your program than what you're currently doing.

References (or borrows in Rust lingo) should be the absolute first thing you reach for when chosing how to pass parameters (&T) and copy or clone cheap types like integers and floats and fat poitner types (like &str &dyn Trait, etc.).

And just to reiterate: Allocations? Not bad when needed but as systems level devs we should try to use the stack as much as we can and only touch the heap when absolutely necessary.

TL;DR: Don't allocate everything on the heap (Box, Vec, String, etc.) because it's easy and 'quick', reach for shared references (&T) first or static (stack arrays or a SmallVec, etc.) data structures before everything else.

Maybe it will sound harsh - but I actually love Rust because it's hard, and it has a steep learning curve. It means - no idiots from javascript will start writing Rust quickly and pour their toxicity as they did to Nodejs community. I consider it a good thing - a wall, defending an awesome Rust community. If you have to explain str and String idea, this means that more people who just don't have any idea about programming to have an easier start, where they should just learn by themselves - read a book or five about the language and ideas behind it. Your knowledge could be used better than that IMHO.