 to you today a little bit about refactoring. I feel about it too. So I feel like when it comes to refactoring, there's two camps. You either love it or you hate it. Or you might be a little bit like me and fall somewhere in between. So I've only been programming for about a year and I've been working with Ruby and I love it. But when it comes to refactoring, I have mixed emotions. So usually for me, I'm not as good of a developer as I want to be that I can refactor my own code. Usually what happens is I show my code to someone, yes, and then they turn it into something way more concise and clearer and sometimes, sometimes even elegant. And on the one hand, this is really, really magical. To see that transform and see your code get turned into something so beautiful, well, it's so magical. But we're developers, which means that there's an inherent element of self-loathing and self-deprecation, right? When someone else can turn your code into something so beautiful, I don't know about you. But for me, I just can't help thinking, oh my god, why did my code not look like that to begin with? So I just, I want my code to be that elegant to start with. And it's really hard for me to accept that that's just not how refactoring works. And I've come to realize that there are lots of different types of refactoring. And there's one type of refactoring that all of us do in this room, despite whatever our skill level might be. And this is a Ruby conference so you know probably where I'm going with this. Yes, I'm talking about self. Self, right? The context that you're in, the receiver of whatever message you're sending it. And the really amazing thing about self and the amazing thing about Ruby is that you can't always see it. It's implicit. But it's always around. So when we're refactoring our code, it's our code that's the receiver of our refactoring. It's our code that's transforming. But what about when we're refactoring self? What is self? I know I love that question. I ask myself that all the time. So what is self when we're refactoring self? Well, in our quest to be better developers, there's one thing we all do, right? We keep on learning. In fact, that's probably what brought most of us here today. We thought we'll learn new tips and tricks and skills and technologies and we'll add them to our tool belt of knowledge. And then we'll go back and we'll look at our code and it'll be magical and it'll just look so great because we'll take all those new things we learned and implement them. We're always striving to improve self. We're iterating on self. We want to be better. We want to strive towards our perfect iteration of self. But here's the thing. Just like with code, you're never really going to be satisfied, right? You're going to keep going towards your perfect iteration of self but you're never really going to get there. But what do we do with code? We ship imperfect code all the time. All the time. And we do the same thing as developers, right? We show up with our imperfect selves and our imperfect code and we keep trying to be better. So one of the things that I've realized is that the way that we approach code is the same way that we should approach ourselves as developers. We have to keep striving to be better and keep iterating and deploy fast, deploy quickly, make tweaks but then accept the fact that you're never going to really get where you want to be. But that shouldn't stop you. So now, when I do something like write the entire group by method without knowing that the group by method exists, I actually get motivated because then I see somebody refactor my code and then I remember that I'm just iterating. I'm learning and I'm getting to the point where one day I'll also be as good of a developer as they are. And even though I might not be refactoring my code as well as I want to, there is one thing that I'm refactoring. Myself. And honestly, refactoring of self is probably the most important type of refactoring that any of us can do. Thank you.