What is Continuous Integration and why do you even care about it? It's a really important question that comes up a lot when I'm teaching students about building software, where I'm working with a company or in a consulting project. A lot of times, it's really something that people misunderstand, they feel like when you do automated testing or you have to write tests, it actually is wasting a lot of time, but it actually saves you a lot of time. Let me give you a few examples. For example, why do you have smoke alarms in your house? Well, presumably, you don't want to silently die in your sleep because there was a lack of oxygen, so it's an automated way to ensure your survival. Likewise, why do we test for new drugs to make sure that they're effective? Well, we want to make sure that the drugs that we're delivering for some medical condition are actually helpful and not harmful. Likewise, why would you wear a seat belt? A seat belt ensures that if there's a sudden event like a crash, that it'll stop you from being ejected from the car. These are all forms of automated testing and safety mechanisms, and they actually save a life. The same thing goes for testing software. What Continuous Integration is, it's a way of always making sure that your software is in known state, and that it actually saves you time. Those are probably the two big things to remember about Continuous Integration is that your software is always knowable. You know what it is, it's working or it's not, and then, it actually saves you time. It doesn't cost you time, it saves you time. Once you understand those concepts, it really frees you to develop software in a much quicker fashion because, like the seat belt analogy with a car, you know that you've got something protecting you, and you can go as fast as you want. Let's dive into some of the technical details of Continuous Integration or CI. A lot of times when you're starting with Continuous Integration, the best step is to work local. Suppose this is a local environment. It could be, let's say a Cloud9 environment, it could be a desktop, it could be a laptop, it could be whatever machine you want. The first steps would be to create a local scaffolding, so you could get a makefile here, you could get your test inside your project, and then, you could maybe create a virtual environment as well. Then, go through here and make sure that the code works, so you could say, maketest, for example. This would ensure that, you've got a checkmark here, you've got it working locally. Once that is set up, the next thing to do would be to make sure that your SaaS build server, like GitHub Actions, is ready to automatically test your code. We'll assume this is GitHub Actions here. Then inside, what will happen is that every time you make a change to this environment, there'll be an event that's triggered that will essentially check out your code, so we'll say CO, and then, it'll go through and test it, that's it. Really, it's a way of replicating what happens locally to the SaaS build server that's in the Cloud, and we can make this a Cloud here. In a nutshell, all Continuous Integration is, is a way of doing the things that you're manually doing over and over again in a repeatable fashion. You see lots of examples of this in the real-world. For example, you wouldn't necessarily want to build a car by hand every single time you're trying to build a car. That's why they have factories to build it. This is a testing factory that automatically test your code and repeats it so that you know your code is always in a known state and that it will save you time.
