In previous modules, we talked about different software development processes like requirements, design, testing. And so, in this video we're going to learn about how do you put these different pieces together to create a work flow or a process that a team can use to build software? And 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. And so the first question that comes to our mind is that why do you need so many models? 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 it's 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. And so since there are so many models out there, we're 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. So let's learn about this classification. So 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, and so they have a very high confidence of the requirements or what they're 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 what they had originally in mind. And so as you can see, a couple things in this model is 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. So generally in this case the changes are not desired and so it's whatever we decided to implement, we continue with that during the development process. The other way of treating requirements is adaptive model. So in adaptive models, the client or the customer generally has an idea of what they want to build, but not quite there, right? So 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 really 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 that says "no, we need to go in a different direction." So again, then the team moves in the different direction and starts morphing the product into something else. And so on and then there could be another you know pivot where they learn about something new. And so in the end, you might end up getting something different than you were originally 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 a product. So that's the adaptive model. Now most of the models that we will talk about, they're not always 100% predictive or not always 100% adaptive. They are sometimes somewhere in between and 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. So let's talk about incremental. So 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. So as you can see that in the increment 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, it 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 an iterative model, you will think about, you need something to go from place A to B. And we're not sure if this will be really needed or not needed. So instead of 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, 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 are building on top of the existing product. And then in incremental, you're just breaking the product in smaller pieces. Whereas theirs, there is 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 adaptive model. Whereas if you don't take the feedback from each of your increments and just keep building one increment and then another increment, then it’s more like a predictive model. So those are the two kind of the 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. So some of them are like agile models, incremental as well as iterative model. And there are some models which have neither increment 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 non-category. So those were the classifications. Now we'll talk about for each of the models, what are the different things that we will talk about? Of course, we will start with the name of the model. Then we're going to talk about the mechanics of the model. Once we talk about the mechanics, we'll talk about some of the characteristics of the model. And then we'll get into where in the predictive and adaptive phase, where this model stands. Then we'll talk about pros and cons of the model. And then we'll talk about where you can use this model. So this is basically going to be our template for all the models that we're going to discuss in this module. So we're going to follow this sequence and learn about these aspects of each model.
