 Thank you so much, everyone, for coming. This is really exciting. It's honestly an honor anytime we have a GitOps specific event, because I think I remember when this was not a community, it was a blog post, right? As all good communities start out as. And just make sure that I will account for time here. So we had a couple of GitOps cons, a couple of GitOps days as well. And now we're sitting here. We've got two tracks, two tracks of lightning talks, two tracks of awesome presentations. And so I'm sure that we've all been sitting around, because we're cool practitioners hanging out in the infrastructure, doing all the things. We've got the super glue out. Some of it got stuck on our hands. It's okay. We just tried to get some sleep at night until we get paged, right? But yeah, you know, my name is Lee Cappelli. I'm into some things, snowboards. I'm Filipino, et cetera. Come chat with me after if you're into any of those things, like being Filipino. And we're all excited about GitOps, right? We got whole communities forming, new tooling. This is dope. But not everyone is always so optimistic, right? In fact, some people maybe make some spicy takes on the Internet saying, oh, you know, those GitOps people, do they really know what they're doing? Haven't we been just doing continuous deployment for a long time? I mean, GitOps is continuous deployment, continuously making sure that the cluster is in the way that it should be, the desired state. This is not new stuff. I mean, you know, I remember having control repos with Puppet and all that stuff. This is DevOps. It's just one of the things that we learned from these brilliant people who've been around for more than a decade, right? And so is this just marketing hype? You know, do we write some software when we really should have had no code? Why do we do this? Why am I still excited about this? I mean, it's been years with me, man. The first thing I want to talk about is that DevOps comes from pain. Right? Remember when we had the Supergoo stuck on our hands? Sometimes it feels like that when we're using our tools. Sometimes we're just trying to get the job done. Why do we do what we do? We got our apps deployed on their servers, and it's not because we want to have good KPIs or when I have that fresh, satisfied feeling of logging into a server and, like, you see that uptime? Dude, that thing's been up for, like, two years. And then you go to immutable infrastructure and you're like, man, my uptime never is over three minutes, you know? So it's about doing the work with each other. The pain comes from the fact that we invite complexity when we try to solve hard problems. And let me tell you, when you're using a bunch of computers and, you know, whatever the clouds or whatever co-locations you've got, it's kind of frustrating sometimes because it seems like you're not the only person who wants to use the computer. You've got to share it with your teams and they want to go and do all these things and you've got to go patch the servers, but they want to go update the apps. They want to deploy all the time, or maybe they don't want to deploy all the time because it breaks all the time. And then you're calling them and debugging on a Thursday. That's not fun. And so as a community, we got kind of good at this, right? We said, hey, we can do better. Let's build some tools. Let's figure out the right patterns. DevOps. DevOps days. Got the DevOps email list, right? Puppet, Chef, Ansible, we got some config management going in. Some smart people invented Terraform. Now I have a bunch of this JSON looking DSL in my Git repotes. It's great. It's tying together infrastructure APIs that were never meant to be glued together in a formal way. You know what, it's true. There's nothing formal about our jobs, right? And then after we got good at that, and stuff sucked a little bit less, then the orchestration wars started. And we're like, oh, I got a new thing to fight for, a hill to die on. Mezos, Kubernetes, mine was the Docker swarm hill. I'd actually did die on that hill. So it was kind of a sad thing because that one was a really nice one to use. But the darling of this ecosystem, right? After we had the problem of application sprawl and then we wanted to try and wrangle it and have good dashboards and tools to keep everything all together, we got Kubernetes, right? This whole conference is basically about Kubernetes, but we call it Cloud Native Cloud. Kubernetes is a very special machine. I want to talk about the machine of Kubernetes because it's special. It's different from what's come before it. Kubernetes is a fast computer and the thing that it computes and the way that you program it is a little bit different than how we used to program things like Puppet, which was kind of this hacked and glued to things together with lots of machines. Kubernetes is a distributed computer. And the way that it gets reconciled is we broke up the reconciler. Instead of having one reconciler on each machine that does everything, we're like, hey, maybe we should have a couple of different control loops that could run anywhere. They'll each get a piece of what needs to be done and we'll use a little bit of promise theory. These controllers will collaborate and they'll all try to take the piece of the puzzle and tell you if the promise is being kept. And then we wrote a little bit of really, really sweet GRPC magic called the Informer. Which is both a pull loop, but also a subscription that is reactive. And so when stuff changes in the computer, stuff that has no business being reconciled as fast as it does. I mean, this has never happened in my puppet data center of 2000 nodes, right? I just update the config map and now it's all over on 200 machines and all the pods are rolling and I go, what is happening? This is like, this is only one puppet run. But Kubernetes is not like that, it's reactive, it's fast, and it's hooked up to a consistent state store. Which is the thing that everybody wanted, right? They were deploying console, you've got vault over here, maybe let's store a distributed lock. You don't gotta do all that complicated stuff anymore, it's in the computer. One computer. And so this thing is pretty fancy. Mechanistically, it's already like, I mean, you guys remember when smartphones had like plastic keyboards? This thing is like way different than that, it's a way better computer. This is a better computer. Now, what do we do with it? Well, we use apps and infrastructure on it. And then, we extend it, except the landscape doesn't look like that anymore. It looks like this. So you can do all the things with the computer. Which means, you have all the people who wanna do all the things. That's pretty dope. So you're like, man, I wanna get me some kubernetes. There's a fast computer with a new programming model about promises, and it can do all these things. It looks like this. Now I got a bunch of clusters, I got a bunch of people to satisfy. And these things are not good at collaboration. Because that's not what it's for. You see, this thing is the Ferrari. It's the thing that gets your job done. But what about the race team? What about all of the engineering that makes the Ferrari go around the track? Well, it's not a forum, it's not a collab tool. You can't version control inside of kubernetes, but you can do that outside. And we can take our programming model to our place of collaboration. And so this is why we do this. We can answer these hard questions. We can say, what does our app need? How much of it? Who does it depend on? You got people asking, what app? What app are you talking about? I got ten of those in a folder over there. Who owns that? What should they have access to? How can we enable them? How can we onboard other teams like them? Do they even know what they're doing? Because it looks pretty sketchy in their folder. How do we keep them safe? How do we know? What do we do? Did we release? A manager is wondering that somewhere. Some CIO. What changed last week? How come we're having problems? What did we do last year? You see, when we ask these questions, we can use our tools to describe ourselves specifically. And our tools, the way that we work with each other, shape our habits. Our habits are individual and they're also organizational. We have communal habits, shaped by the way that we work with each other. And sufficiently advanced tools when everybody can use them. And everybody has a reason to use them. When you have a computer that can do so many things and it's so good at it, stuff actually fundamentally changes. This is innovative. This is changing the way that our industry works because now we talk to each other, we build community, we have ways of working that translate across the industry. And so when you're thinking about when your software becomes legacy, maybe you can ask yourself, what sorts of habits do we need to do today so that in five years, legacy is not a bad word. Maybe it's a good word. And so we got Kubernetes. It's this computer that can make promises for us, but if we're talking about GitOps, GitOps is about making promises to each other. Thanks. Thank you.