Doug, I have finished chapter 10 and beginning 11 in the Rust Book. I have listened to all of your Rust tutorials. Thank you, after a stroke and disability from chronic pain, it has taken 2 years to get here. I can listen and understand all of them now. They are great. They have not only gifted me with knowledge,they have given me many hours of distraction from my abdominal pain. I just wanted you to know that. And again, thank you from the bottom of my heart. Your friend, Scott.
Absolutely! Thanks Doug, for putting so much work into your Rust tutorials. I've seen tutorials from other people before but this is by far the best! I will definetly recommend it !!!
Even after 3 years, this is still the best explanation there is to rust lifetimes, any chance we'll be seeing a smart pointer, declarative and procedural macros explanation?
This is absolutely the best explanation of Rust Lifetimes I've found, either on TH-cam, online Tutorials or books. Thanks for delivering such a wonderful tutorial video!
I have to agree with many of the comments already here... best explanation I found of lifetimes. I think that possibly, maybe, could be that I might understand lifetimes now ;) Thanks Doug!
Fantastic explanation, especially by showing the "unnecessary" parts that the compiler usually does automatically. It helped me fix my TryFrom implementation within a minute, and it's much clearer to me now.
this is absolutely brilliant! i had no idea that every reference has a lifetime, that it is implicitly inserted, and that it is different for every reference. knowing this makes rust lifetimes a much easier topic to understand and handle. it is also quite logical. thanks a lot!
what a fantastic coverage of lifetimes in rust. I'm here after reading the section in the rust book and watching this cleared up most of the issues I had with what I read in the book. thank you for this!!!
The whole serie on Rust is greatly educational ! Very clear explanation, straight to the point, best tutorials on Rust I have found. Thank you for the great content !
Dough, you’re doing a fantastic job with these videos. I usually prefer written materials but when the book doesn’t explain something clearly, your video is usually the answer.
Since 3 days I was researching about lifetimes on the articles, and then I saw your video.. It is the only best explained resource that I could find on the internet.. A simple thanks would not be enough to express the time and effort you saved me, learning this concept. And it is such a beautifully explained concept, that I hope that you don't delete this video, or make it private. I would be bookmarking this video on my notes app.
Awesome! Doug's videos are of high quality and condensed with valuable content. Doug is a fantastic educator with unusual abilities to keep you up and focused. This video comes right on time and happens to be very helpful to me in `digesting` the notorious Rust Book. Thanks Doug.
This was great. I tried a few videos, a few examples, and tried to read the Rust book. But this video was so clear, had many examples (much appreciated), not complicated, and to the point. I was able to follow along, write the codes myself, and take notes and not get tired, bored, or lost. Great job. Will come back for more.
did you understand the part where he passed a const variable and a normal variable to a function with same lifetime 'a? const was outside the main function and has lifetime of the program and normal variable inside the function has a lifetime of main fn, how can that be equal? is it because main is the last function to exit the stack and the program ends so rust considers the variable declared inside main fn to be the same lifetime of 'static?
Very nice and clear lecture. At 15:20, I think it would be more appropriate to say that the lifetimes of the parameters passed in are known to outlast the function, because the caller (or someone up the call stack) has the ownership. I.e., it's not because you're not returning a reference, but because you can't deallocate the memory the input reference refers to from inside the function. You necessarily have to return from the function (and drop the reference) before the caller will have a chance to deallocate what the reference was pointing to. If you passed in both the reference and ownership, you could do that, but you wouldn't be able to because of the only-one-mutable rule.
Hey, Darren, thanks! I appreciate it :) The Lifetime of reference parameters passed in for sure outlast the function. So I agree with you on that. If you never return the reference parameter via the output, though, I'm not sure you'll ever get a lifetime issue. Returning the reference is what causes the compile error because of the potential issue of using the resultant reference after memory gets cleaned up (lifetimes are always there in the background... it's just not necessary to make the developer handle them in many situations). I'm not 100% sure what you mean about passing in both the reference and ownership. But maybe I'm just not understanding. If I somehow misinterpreted your question/comment, let me know. I think you're trying to make a good point. I'm just not sure if I fully understand. Maybe if you gave an example that would help me understand? And, if I misspeak at some point, I appreciate when people catch me and correct it in the comments. I do my best to be thorough and correct, but now and then everyone has a slip of the tongue. So thank you for helping clarify if there's confusion :) Doug
I don't know you could sub-type lifetimes. I don't think enough attention is called to this in the official documentation, and it didn't occur to me that *this* is how you disambiguate certain problems that come up. It's a feature that needs to get more attention when Rust lifetimes are discussed.
Awesome. Your video tutorials are just awesome. Looking forward to and hoping your next topic is "Rust closures/lambdas". Don't forget to inject humors in your videos. They're great.
Lifetimes are an integral part of any reference type, although it's often hidden. Any reference can easily be converted (downcast?) to a reference of shorter lifetime. That's why a single generic lifetime, like fn testtwo { one } else { two } } fn main() { let a = "hello"; { let b = "world"; { let c = test(a, b); println!("{}", c); } \\ c dies here } \\ b dies here } \\ a dies here works, even though there are three distinct lifetimes for the three variables. As a and b are passed into the function, a is downcast to a reference with the lifetime of b as it is bound to the variable one. This makes the inputs have the same lifetime, as required. The return therefore has the same lifetime: the lifetime of b. When the returned reference is bound to c, it gets downcast to have the lifetime of c. This isn't to disagree with anything you said. But I don't think it was mentioned explicitly, and coming to this realization is what made lifetimes in function signatures click for me. I do wish this video had existed two years ago, though. Would've helped me out a lot.
this is owsome explaination , you can think to create the full course on rust on udemy or pluralsight , currently there is no course available which explain with this ammount of detials you shared . thanks for your effort
Well explained tutorial with concrete examples. I still don't understand why you would need more than one lifetime for a given function. One suggestion to help make the concepts clearer would be to define variables in different scopes and then pass them to a function as references and returning each one based on some condition. Moreover, it's also a bit odd that a function would be concerned with more than a single lifetime. Shouldn't the caller be responsible for managing the scope of the references it passes to the function? All the function should care about is alerting the caller the return value is no longer owned by the function.
Yeah, the Lifetimes video I totally goofed. I recorded the whole thing and only saw the issue right before I was about to publish. You're not the first to notice on this video that the font's too small.
these series are too good. I would love to watch a video to learn more about you, how you got involved with Rust, how you learned it, etc. This is some quality content. So thanks!! Question: Do you have a plan to do any videos on Actix web?
As a rust beginner, this makes sense to me. I would like to suggest a new video on Rc. As I understand it, it would allow me to not care so much about lifetimes at a small runtime cost but the usage patterns on the rust website seem unclear to me.
Rc has it's uses. It has some drawbacks as well, such as having to being immutable unless you use something like RefCell. Also, it's single threaded, so if you needed to process something in parallel on multiple cores, it's not really going to help you. There's the multi-threaded counterpart to Rc called Arc. But that is not a magical cure. A deep understanding of concurrent and parallel processing is needed to properly utilize it. As I'm writing this, I'm realizing just how necessary it is to do a video on this stuff. So, thanks for asking about it! I'm currently working on a Macros video so that you can have code writing code. After that video, I think I'll swing back to this topic.
Yeah, it's a very tricky topic. Except for creating Macros, I would say it's the toughest topic to wrap your head around in Rust. Hopefully you learned enough to at least be functional. I think a lot of learning it is running into situations and thinking about why you're getting a compile error. Let me know if you run into any specific situations that are giving you trouble and perhaps I can speak directly to that. Sometimes a specific example is what's needed to help clear the fog.
Hey, great videos and nice job on the vocal recordings! You forgot to put a link to the memory management video in the description :) or maybe you didn’t think about it, but it would be nice!
very good explanation but the biggest mystery remains: when would giving different lifetimes to parameters be appropriate? In all examples with compiler errors, giving them the same lifetime fixes the issue. The compiler avoids doing that so there must be some cases where that would not be appropriate. I have seen no examples of that.
(25:00) i have tried to create a struct with one reference field and it still gives a compile error saying that i need to provide it with an explicit lifetime parameter. why rust does not assume that the lifetime of the reference field is the same as the lifetime of the whole struct? i.e. why this: ``` struct MyStruct { my_reference: &Vec, } ``` does not get converted into this: ``` struct MyStruct
Closures and Multi-Threading Hi @Doug Milford, I've been watching all of you Rust videos to learn Rust. I also read "the book". But it is easier to learn watching you writing the code and explaining it. Do you have plans to make videos about closures in Rust and - what is most interesting for me - multi-threading? It is always said that Rust is the safest programming language when it comes to multi-threading because of the ownership and borrowing mechanisms. In the book there is a chapter about "fearless concurrency". But as said before, for me it is more beneficial to watch you explaining these things while writing a little program.
Yes, that's certainly on the top end of my list to do. It's a very important topic. At the moment I'm swamped working on a new programming framework that utilizes Rust and allows web development without css and html. But I'm hoping to circle back to the videos soon. Thanks for watching!
Awesome videos! Many thanks for your time and these truly valuable videos that you share with Rust community. And if there is any possibility to increase the font size of your editor (VScode) in your videos, much to the better.
Doug, I have finished chapter 10 and beginning 11 in the Rust Book. I have listened to all of your Rust tutorials. Thank you, after a stroke and disability from chronic pain, it has taken 2 years to get here. I can listen and understand all of them now. They are great. They have not only gifted me with knowledge,they have given me many hours of distraction from my abdominal pain. I just wanted you to know that. And again, thank you from the bottom of my heart. Your friend, Scott.
This is the best explanation of the lifetime concept that I found on TH-cam.
Hey, thanks :)
Easily! I wish I had this when trying to learn the first time around, this makes things much clearer.
Yaaayyyyy!!! I'm glad people are getting so much benefit from this video!
Absolutely! Thanks Doug, for putting so much work into your Rust tutorials. I've seen tutorials from other people before but this is by far the best! I will definetly recommend it !!!
@@karuma1959 Awesome! Thanks for helping my channel gain traction. I appreciate it :)
hands-down the best RUST videos for beginners on youtube.
I love the way you explain the details of Rust, satisfy me a lot
Even after 3 years, this is still the best explanation there is to rust lifetimes, any chance we'll be seeing a smart pointer, declarative and procedural macros explanation?
I read the rust book over and over and didn't understand it until I watched this video. Thank you sir!
The best explanation on Lifetimes. I referred a Oreilly book, a nostarch book and spent a entire day. Could not comprehend. This video did it.
2 years ago. Still helping people. Thanks a lot !
Rustaceans don't look any further, this is the best explanation there is to rust lifetimes!!!
this is by far the most comprehensive explanation of rust lifetime I have ever seen.
Ah, thanks!
Incredible resource for this topic here, thank you for your time!
I would have quit Rust without this channel. Thank you Doug!!
Only a few minutes in and it's already more clear than most guides on the net. Thanks!
Hey Doug, this is really helpful. Could you please make a video explaining the Smart Pointers in Rust?
This is the most comprehensive and clear explanation of the concept of lifetime that I have come across on TH-cam. Thanks a lot!
This is absolutely the best explanation of Rust Lifetimes I've found, either on TH-cam, online Tutorials or books. Thanks for delivering such a wonderful tutorial video!
The best explanation I've found on youtube and outside of youtube. Lifetimes never clicked until now, thank you so much!
I have to agree with many of the comments already here... best explanation I found of lifetimes. I think that possibly, maybe, could be that I might understand lifetimes now ;) Thanks Doug!
I've read the chapter 10 of the Rust Programming Language book, but I found the best explanation here.
Thank you so much!
Fantastic explanation, especially by showing the "unnecessary" parts that the compiler usually does automatically. It helped me fix my TryFrom implementation within a minute, and it's much clearer to me now.
Whoo hoo!!! So glad the video helped :)
this is absolutely brilliant!
i had no idea that every reference has a lifetime, that it is implicitly inserted, and that it is different for every reference.
knowing this makes rust lifetimes a much easier topic to understand and handle. it is also quite logical.
thanks a lot!
what a fantastic coverage of lifetimes in rust. I'm here after reading the section in the rust book and watching this cleared up most of the issues I had with what I read in the book. thank you for this!!!
Literally the best video or explanation I've seen on lifetimes, including all the usual rust books I've read, thank-you!
Doug, your videos are a fantastic resource! Thank you and have a great day!
You're very welcome! Thanks for the support :)
thank you for blessing us with your divine intellect.
The whole serie on Rust is greatly educational ! Very clear explanation, straight to the point, best tutorials on Rust I have found. Thank you for the great content !
Exactly what I needed. So many examples, fast enough so I don't get bored.
Glad you like it :)
Dough, you’re doing a fantastic job with these videos. I usually prefer written materials but when the book doesn’t explain something clearly, your video is usually the answer.
Ah, thanks!
Agreed, best lifetime tutorial on the tubes
Very nice! Thank you.
Well Mr Doug Milford from Lamda valley .. you are one hell of a teacher..
Thank you very much! that was really helpful.
This is actually the best explaintion of lifetime in whole internet
I learned a lot from this even after reading the rust book. Thank you!
This video is pure gold, thanks so much.
Since 3 days I was researching about lifetimes on the articles, and then I saw your video.. It is the only best explained resource that I could find on the internet..
A simple thanks would not be enough to express the time and effort you saved me, learning this concept. And it is such a beautifully explained concept, that I hope that you don't delete this video, or make it private. I would be bookmarking this video on my notes app.
Oh, amazing lesson, you saved my day. Thank you !
Awesome! Doug's videos are of high quality and condensed with valuable content. Doug is a fantastic educator with unusual abilities to keep you up and focused. This video comes right on time and happens to be very helpful to me in `digesting` the notorious Rust Book. Thanks Doug.
Yep, yep... my pleasure :)
Thanks for clarifying on lifetimes, Doug.
Hope you’re doing well since I haven’t seen any recent videos.
This was great. I tried a few videos, a few examples, and tried to read the Rust book. But this video was so clear, had many examples (much appreciated), not complicated, and to the point. I was able to follow along, write the codes myself, and take notes and not get tired, bored, or lost. Great job. Will come back for more.
Thank you for the great videos
These videos of Rust by Doug Milford need to be in the official documentation of rust
mithradates channel sent me here, and I am happy for it. This was beautifully explained
Excellent explanation, no need to check the documentation again for my lifetime 😀
Great talk that helps to drive the intuitive understanding on Rust’s Lifetimes!
Thank you so much for your excellent Rust content, Doug. Your videos are the best guides to learning Rust I have found.
1:33 - Howdy, partner!)
Terrific videos -- clear, well constructed, and weirdly entertaining. Thanks for these!
most helpful video about lifetime
You are the best teacher
Really good, thank you. I would love a usecase where you'd WANT to have different lifetimes though.
did you understand the part where he passed a const variable and a normal variable to a function with same lifetime 'a? const was outside the main function and has lifetime of the program and normal variable inside the function has a lifetime of main fn, how can that be equal? is it because main is the last function to exit the stack and the program ends so rust considers the variable declared inside main fn to be the same lifetime of 'static?
These videos are seriously flattening the learning curve... Amazing... Thank you...
What a beautiful explanation
I watched every second of all your rust tutorial series. I would like if you make a video about . closure ( inline function ). Great Work!!!
Very nice and clear lecture. At 15:20, I think it would be more appropriate to say that the lifetimes of the parameters passed in are known to outlast the function, because the caller (or someone up the call stack) has the ownership. I.e., it's not because you're not returning a reference, but because you can't deallocate the memory the input reference refers to from inside the function. You necessarily have to return from the function (and drop the reference) before the caller will have a chance to deallocate what the reference was pointing to. If you passed in both the reference and ownership, you could do that, but you wouldn't be able to because of the only-one-mutable rule.
Hey, Darren, thanks! I appreciate it :)
The Lifetime of reference parameters passed in for sure outlast the function. So I agree with you on that. If you never return the reference parameter via the output, though, I'm not sure you'll ever get a lifetime issue. Returning the reference is what causes the compile error because of the potential issue of using the resultant reference after memory gets cleaned up (lifetimes are always there in the background... it's just not necessary to make the developer handle them in many situations).
I'm not 100% sure what you mean about passing in both the reference and ownership. But maybe I'm just not understanding.
If I somehow misinterpreted your question/comment, let me know. I think you're trying to make a good point. I'm just not sure if I fully understand. Maybe if you gave an example that would help me understand?
And, if I misspeak at some point, I appreciate when people catch me and correct it in the comments. I do my best to be thorough and correct, but now and then everyone has a slip of the tongue. So thank you for helping clarify if there's confusion :)
Doug
Thanks for the time and effort Doug.
Thanks for the insightful explanations!
I have been going through all of your Rust videos and your explanations are super clear and to the point.
Hey, thanks! I'm glad you like them :)
I don't know you could sub-type lifetimes. I don't think enough attention is called to this in the official documentation, and it didn't occur to me that *this* is how you disambiguate certain problems that come up. It's a feature that needs to get more attention when Rust lifetimes are discussed.
Thank you! This really helped brush up on my skills!
Thanks so much! Your explanation solved a lot of issues I've had with this topic.
You are a god amongst gods. Thank you for this excellent explanation.
Hi Doug. I've watched all your videos and love the clarity of concept you produce. A natural teacher. Nameste.
Thanks, Mage! I'm really glad you liked them :)
This was good. Lifetimes are a pain at first, for certain. Thanks for the share.
Great job. I'm going to share this with a new hire.
Awesome. Your video tutorials are just awesome. Looking forward to and hoping your next topic is "Rust closures/lambdas". Don't forget to inject humors in your videos. They're great.
Thanks! Currently working on Macros videos, but I'll move closures/lambdas up the list.
Thank you so much for this! Very clear, and detailed, even good humor.
really concise and practical explanation! thanks a lot!
Glad it was helpful!
WOW, I finally undedrstand frickin lifetimes
It's very clear, thank you.
I am having trouble with Macros. Can you have a video to explain it?
thid was super helpful. thank you!
The best explanation!!
Very thanks for your videos, your teaching skills are amazing. The best Rust learning content I found.
Lifetimes are an integral part of any reference type, although it's often hidden. Any reference can easily be converted (downcast?) to a reference of shorter lifetime. That's why a single generic lifetime, like
fn testtwo {
one
} else {
two
}
}
fn main() {
let a = "hello";
{
let b = "world";
{
let c = test(a, b);
println!("{}", c);
} \\ c dies here
} \\ b dies here
} \\ a dies here
works, even though there are three distinct lifetimes for the three variables. As a and b are passed into the function, a is downcast to a reference with the lifetime of b as it is bound to the variable one. This makes the inputs have the same lifetime, as required. The return therefore has the same lifetime: the lifetime of b. When the returned reference is bound to c, it gets downcast to have the lifetime of c.
This isn't to disagree with anything you said. But I don't think it was mentioned explicitly, and coming to this realization is what made lifetimes in function signatures click for me.
I do wish this video had existed two years ago, though. Would've helped me out a lot.
You make a good analogy and it may be helpful to others struggling to understand the concept. Thanks!
Thanks for this!
this is owsome explaination , you can think to create the full course on rust on udemy or pluralsight , currently there is no course available which explain with this ammount of detials you shared . thanks for your effort
it was a good basic explanation, but i felt some things were missing like the usage of lifetimes in impl blocks? You only touched structs in the end
Very nicely explained!
Well explained tutorial with concrete examples. I still don't understand why you would need more than one lifetime for a given function. One suggestion to help make the concepts clearer would be to define variables in different scopes and then pass them to a function as references and returning each one based on some condition. Moreover, it's also a bit odd that a function would be concerned with more than a single lifetime. Shouldn't the caller be responsible for managing the scope of the references it passes to the function? All the function should care about is alerting the caller the return value is no longer owned by the function.
This was an amazing video, thank you so much
Hi Doug, Your videos are helping me a lot.
I'd suggest you to increase the font size. Thank you.
Yeah, the Lifetimes video I totally goofed. I recorded the whole thing and only saw the issue right before I was about to publish. You're not the first to notice on this video that the font's too small.
these series are too good. I would love to watch a video to learn more about you, how you got involved with Rust, how you learned it, etc. This is some quality content. So thanks!! Question: Do you have a plan to do any videos on Actix web?
As a rust beginner, this makes sense to me. I would like to suggest a new video on Rc. As I understand it, it would allow me to not care so much about lifetimes at a small runtime cost but the usage patterns on the rust website seem unclear to me.
Rc has it's uses. It has some drawbacks as well, such as having to being immutable unless you use something like RefCell. Also, it's single threaded, so if you needed to process something in parallel on multiple cores, it's not really going to help you.
There's the multi-threaded counterpart to Rc called Arc. But that is not a magical cure. A deep understanding of concurrent and parallel processing is needed to properly utilize it.
As I'm writing this, I'm realizing just how necessary it is to do a video on this stuff. So, thanks for asking about it! I'm currently working on a Macros video so that you can have code writing code. After that video, I think I'll swing back to this topic.
@@dougmilford7814 +1 on a macros video. You have a great way of explaining things that ought be easier to understand. :-)
You got it, my man! I'm on it :)
this has taken me months to understand but i'm finally getting there I think
Great walkthrough.
wow you do a great a job at breaking down lifetimes, thanks
Watched this video a couple times and still a bit confused, but a hundred times less confused about lifetimes than I used to be.
Yeah, it's a very tricky topic. Except for creating Macros, I would say it's the toughest topic to wrap your head around in Rust. Hopefully you learned enough to at least be functional. I think a lot of learning it is running into situations and thinking about why you're getting a compile error.
Let me know if you run into any specific situations that are giving you trouble and perhaps I can speak directly to that. Sometimes a specific example is what's needed to help clear the fog.
hello what is your rust debug extension name?
Hey, great videos and nice job on the vocal recordings! You forgot to put a link to the memory management video in the description :) or maybe you didn’t think about it, but it would be nice!
Doug, you've accomplished what The Rust Book failed to!
Thanks so much for the explanation, subscribed!
Hey, great! I'm glad you liked it so much :)
very good explanation but the biggest mystery remains: when would giving different lifetimes to parameters be appropriate? In all examples with compiler errors, giving them the same lifetime fixes the issue. The compiler avoids doing that so there must be some cases where that would not be appropriate. I have seen no examples of that.
Félicitation, les tutoriels sont excellents .. Merci
Merci! J'apprécie le compliment.
this man is an absolute sav, tysm!
Looks like you're getting a lot out of the videos. I'm glad!
great tutorial thank u so much 🙏
(25:00) i have tried to create a struct with one reference field and it still gives a compile error saying that i need to provide it with an explicit lifetime parameter.
why rust does not assume that the lifetime of the reference field is the same as the lifetime of the whole struct?
i.e. why this:
```
struct MyStruct {
my_reference: &Vec,
}
```
does not get converted into this:
```
struct MyStruct
Life times are simple. the only reason they are seen overly complicated by many is because this video does not have a clickbait thumbnail.
please use clickbait it will help so many 😂
You're a life(time)saver!
I'm glad you liked it :)
Doug, 'a is great, never knew, Thanks for sharing your insights.
Sounds like you got some good stuff out of the video. I'm glad!
@@dougmilford7814 definitely! meticulous thing explained in layman terms. thanks again.
Closures and Multi-Threading
Hi @Doug Milford, I've been watching all of you Rust videos to learn Rust. I also read "the book". But it is easier to learn watching you writing the code and explaining it.
Do you have plans to make videos about closures in Rust and - what is most interesting for me - multi-threading?
It is always said that Rust is the safest programming language when it comes to multi-threading because of the ownership and borrowing mechanisms. In the book there is a chapter about "fearless concurrency". But as said before, for me it is more beneficial to watch you explaining these things while writing a little program.
Yes, that's certainly on the top end of my list to do. It's a very important topic. At the moment I'm swamped working on a new programming framework that utilizes Rust and allows web development without css and html. But I'm hoping to circle back to the videos soon. Thanks for watching!
Thanks for the great explanation Doug!
Yup, my pleasure!
I love how you can write rust without even having to compile and check if everything works
Thats vscode + Rust RLS -> using Rust Analyzer plugin
@@ajinkyax Is rust analyzer available for VIM?
@@secondaryaccount8155 yep! coc.vim + coc-rust-analyzer works like a charm !
I am studying Rust and don’t even know why. But this is very interesting (and weird!)
Awesome videos! Many thanks for your time and these truly valuable videos that you share with Rust community. And if there is any possibility to increase the font size of your editor (VScode) in your videos, much to the better.