I know it took effort to create and all that stuff but come on, remove the registration bs and just make it free to download or just don’t at all.

​@@essentialGI support It doesn't look like it's free if you have to sign up.

The "longest of two strings" is the example from The Book, and everyone uses it, but very few explain what's actually going on. This video is no better in that regard. One video that does explain what's going on (or at least is honest about the fact that there is more going on, and tries to begin pulling on that string, because it's way too much to cover in 10 minutes), see "but what is lifetimes" by leddoo. For a more thorough introduction, Jon Gjengset has an hour and a half of "Crust of Rust: Lifetime Annotations".

@@MasterHigure Thanks for the pointers to some deeper dives. But yeah, what I appreciate about this video, is that it gets the gist across very concisely/quickly by leveraging animation/visualization.

So how to solve it?

I find with a lot of tech, I need to learn from a combination of reading, listening, watching and practicing. I pick up different things from each medium.

@@kevinmcfarlane2752Totally agree, some things are easier to learn from theory than practice and vice versa.

...or clone/dereference the value of `last()` so that the value that we add to the local stack (variable reference) *is* the integer rather than a pointer into the heap.

7:15 yeah i was thinking same. thanks for mentioning it. this particular example shown in video is not practical, but i reckon that he was just focussing on the borrow validation.

@@yash1152 it is pretty practical actually. It actually proves the rule is incorrect as stated. The actual compile error speaks in terms of time / location of usage.

This. Fixing a problem by writing the wrong business logic is not a good advice.

I think Java's Generational ZGC is interesting, it has sub-ms pauses

Rust's borrow checker checks lifetimes one function at a time. The function signature contains everything necessary to know if there are borrowing mistakes in it. Without this understanding, borrow checker might seem as this complex system that traces lifetimes across modules. Nope. One function at a time. The function signature is the key to understanding lifetimes.

The reason why Haskell failed compared to Rust is that the Haskell community's attitude towards people who complained about the complexity of the language was along the lines of "Maybe you are not smart enough for the language like we are? Too bad, because this language is superior to every other language once you understand it.". Rust took different approach and invested heavily in material that focused on making the language as easy to learn as possible through official language book / tutorial, in-code documentation code examples (for every standard library function you have instant access to not only the documentation of what the function does but how it is used with runnable code examples) and community efforts.

@@meanmole3212Yes, imagine if Rust didn’t have that stuff. Many would just have moved on after the first hour.

@@meanmole3212 The century is still young -- Haskell still might catch on, but I'm hoping that something Lisp-y will get there first.

Evangelists have already climbed the learning curve (or at least I hope so, though I know some who evangelize even when they barely know stuff themselves).

Please..... @letsgetrusty

Read rustbook

He already did lmao

I second this, from South Africa 🌍

He did, 2 years ago

It's pretty typical to use 'a as a "throwaway" lifetime when you don't think it's important to give it a better name. Just habit in this case.

Yup, it does change the behavior. If you want to add 4 to the list while still having `last` to evaluate to 3, move `x.push(4)` below the println. He gets the main point delivered, but code examples could be better.

Actually, you just need to move the push down, making it after the print statement. He stated the rule incorrectly. An immutable reference can exist here, but no mutations should happen before the use of the immutable reference. This is fine: fn main() { let mut x = vec![1, 2, 3]; let last = x.last().unwrap(); println!("{:?}", last); x.push(4); println!("{:?}", x); }

In fact, the error speaks in terms of time / location of usage. It does not say "cannot make an immutable borrow". Ref: rustc --explain E0502

Rust tries to avoid doing things "by default" and instead relies on the programmer to tell it how to handle a situation. Explicit ".clone()"s, borrows and moves make it very easy to avoid memory bugs and work alongside other programmers who's brains you do not have access to.

@@theninjascientist689 That is true. But the point I was trying to make was that the "relies on the programmer to tell it how to handle a situation" will eventually be a thing of the past. There was a time when handwriting assembly was the best solution because compilers were not yet good enough for optimal code. In the meantime, until automatic memory management becomes the norm, the borrow checker will be a vital tool in most system languages.

I was looking at gdscript vs C# and one comment said reference counting is garbage collection, just another form of it, I wonder what could be argued against that.

@@xdanic3 Yeah, garbage collectors AFAIK uses reference counting to track lifetimes. However, Swift uses something they call "automatic reference counting" ARC. I'm not sure exactly how it works, though, but they claim it's not a garbage collector.

Yep. Exactly what I just said a couple of minutes ago! 😊 But you just have to keep plugging away. It’s satisfying when you get there.

@kevinmcfarlane2752 is it really worth it tho? some of the most elegant, concise and clean code I've seen was written in rust. but the opposite is also true. if there's not an idiomatic way to do something, the code ends up looking really ugly and unsatisfying

From all the languages showed, outside of C, C++ and Rust, C# is the one that gives you the lowest level control.

Macros are indeed weird, but they're kind of already not in the language. Rust macros are code that writes Rust code. Most beginners shouldn't be reaching for macros as a tool to solve their problems.

Procedural Macros are one of the things that attracted me to Rust.

Macros is unfortunately needed in order to simplify a lot of stuff that is incredibly tedious to write in pure rust. It is used extensively in language bindings. There is a reason people complain so much about boiler plate in C and or make ad-hoc code generators on a project by project basis. But it seems that Zig's comptime is a better way to do it.

@@NicolaiSyvertsen Can you give me some examples of what you've had to write macros for? I'm curious