Welcome to week three. Interesting fact, the Linux Kernel, Linux is a popular operating system where you might run a web application, it's got about 15 million lines of code, 15. A large application that you might run on top of that operating system is, say, 100,000 lines, it's very big. So, 99% of this code that you're using is code that you didn't write, and it's actually a great thing because why write a bunch of code that you don't have to? Your competitor does that and makes better use of these off-the-shelf components, they'll probably running at a much lower cost especially it's a ongoing maintenance. So, this use of really well-put-together standard components is an increasingly important part of software development and helping to organize this standardize all-that-stuff under the hood and giving it some place to run properly and keeping it operating, these are generally the jobs of operations.. So, prior to this, we've looked at the idea of DevOps and the idea of a Pipeline, we've talked about how both developers and testers create a test stack. Now, we're going to look at how they interact with this general job of operations to keep stuff running. What we're going to do is look at the fundamental jobs of operations. So, regardless of whatever technology or trends are changing the way that this job is done, what are the basic things that have to get done in this area so that you can think about how you're doing them now versus how you might want to evolve them based on emerging methods and patterns and tools and facilities that are available to potentially help you operate even better? There are two really big changes in this area that are driving a lot of this change that you may see. One, is the movement to more what people generally call Serverless Architectures. The basic idea is that rather than getting our own physical servers and putting them someplace and operating them and owning them, it is economically more scalable for somebody else to just have a gigantic, totally automated, huge scale capability and rent those back to us. So this idea of a Serverless Architecture where we're getting more of an abstraction, somebody else takes care of all the underlying details, is changing a lot of what this job is about and how it's done and who does it. Then the second, tightly related idea is that, now that we can do all of these things and there's less of this physical maintenance and custom configuration and things like that, we can treat this infrastructure as code itself. So for example, rather than writing this three pages that have 12 elaborate steps that I have to log in to server one and do and login to server two and do which I've done and was terrible, now, what we might do instead is as a team or as an operations person or a DevOps person, write a configuration file of some sort that feeds into some sort of a platform and automatically does all that stuff. This is the analog to automated testing in the job of Ops. This allows us to standardize what we're doing, test it as we go along, and make it extremely repeatable and scalable and generally less terrifying and less error prone to upgrade our software and roll out new infrastructure. So, those are the things we're going to cover here in week three as we dive into the job of Ops.