In previous modules, we talked about different software development processes like requirements, design, testing. In this video, we're going to learn about how do you put these different pieces together to create a workflow or a process that a team can use to build software. There are lots of models out there, of course, you can create your own, but in this module we're going to talk about all these different industry standard models that are out there, that you can use for a team. The first question that comes to our mind is that, why do we need so many models? Like, couldn't you just have one model and then everybody follows it? Well, every team, every project, every organization is different, and the constraints that are on any project are different. So one project, one model may fit a particular project, whereas the same model may not fit for another particular project. So, that's why its important to learn about different models so that when you are in a situation to select a model for your project, you can choose the right model. Since there are so many models out there, we are going to first learn about how do you classify these models, so that it allows us an easier understanding of these models. One of the classifications of these models is Predictive versus Adaptive. Let's learn about this classification. Predictive means that you have a pretty good understanding of the requirements of the software or the product that you are building. So in this case, the client, or the analyst, or the customer knows what exactly they want. They have a very high confidence of the requirements or what they are looking for. And so once the requirements are defined completely, then the team goes through this design, implementation and testing phase, or the process that you have learned, and then finally, produces the product that the client is looking for and they get exactly what they are looking for or what they had originally in mind. And so as you can see, a couple of things in this model are that you get the product in one shot in the end, and since the requirements are known in the beginning, there is generally a desire not to allow changes during the development phase. Generally in this case the changes are not desired, and so it's like whatever we decided to implement, we continue with that during the development process. The other way of developing or treating requirement is Adaptive models. In Adaptive models, the client or the customer generally has an idea of what they want to build, but not quite there, right? They have an idea, but they are not 100% sure what they want to build. So in this case, they start with an idea, the team that is working on it, they actually build something like a very small version of it or like a low fidelity version of it, and then, they show it to the customer or the actual users using it, and then they build the next version based on the feedback. And so they change as they are getting the feedback. So, let's say after the two increments, they got a major feedback, like, this is no, we need to go in a different direction. So again, then the team moves into a different direction and starts morphing the product into something else, and so on. And then, there could be another period where they learn about something new. In the end, you might end up getting something different than you originally were thinking, but actually what you get is what users' need, because all along they were getting feedback as to what will work or not work, and they build the product. So that's the Adaptive model. Now, most of the models that we will talk about, they are not always 100% Predictive, or not always 100% Adaptive, they are sometimes somewhere in between and it depends on how much you allow change during the process. The second kind of classification of models is Incremental versus Iterative, and this is about how you actually build the software. Let's talk about Incremental. In an Incremental model, you have a fairly good idea of what you want to build, but instead of building it in one shot, like we saw in the Predictive model, you build in increments. So, for example, let's say I wanted to build a car. So in this case, the first step I can just build all the tires. I can create all the tires. Once I create the tires, then maybe in the next increment I create the chassis for the automobile or the car. And then, maybe in the next increment, I can put the steering, maybe the engine, and some more pieces, and so on. And then finally, in the end I build my car. As you can see, that in the Incremental you still have a good idea of what you want to build, but you're building in increments. Now in this model, the Incremental model will be useful if your organization can benefit from some of these intermediate products, or if they are going to change the later increments based on the feedback from the previous increments. Now, the other model is the Iterative model, where again, you don't have that clear of an idea, but some idea. So, for example, let's say again your idea was to go from place A to place B. So in Iterative model, you will think about, oh you need something to go from place A to B and we are not sure if this will be really needed or not needed. So, instead of you know kind of building the car, why don't we just build a bike first, which is less expensive, or less effort and see if we need that or we need to morph it. And so, you build a bike and then say, well and it takes a lot of time, so the next iteration you might build a bike, and put an engine to your bike, and now it becomes a motor bike, and so on. And at some point, you might build a car, or you might make a semi truck or something like that. But in an Iterative model, you sometimes are actually replacing what you've built with something different. So, the difference between Incremental and Iterative is that you're building on top of the existing product, and then in Incremental you're just breaking the product into smaller pieces, whereas there are enhancements that are happening during an Iterative model. Now, if you look at the Incremental model, it can go Predictive as well as Adaptive. If you take the feedback from each of your increments and change your future increments, then it becomes a little bit of an Adaptive model. Whereas, if you don't take the feedback from each of your increments and just keep building one increment then another increment, then it's more like a Predictive model. So, those are the kinds of classifications that I wanted to share. So, these were the Incremental and Iterative models. Now, we need to add two more variations to this classification which is Both or None, because some of the models actually have both going together, some of them are like Agile models which are Incremental as well as an Iterative model. And there are some models which have neither Incremental nor Iterative, they are purely one-shot big bang development. For example, the Predictive model example that I showed you in the previous slide, was where we had a definition of the product and we just one-shot, we created the product. So I would call it in the None category.