[MUSIC]
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 that 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,
you're going to first learn how do you classify these models so
that it allows us easier understanding of these models.
One of the classification 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 of 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 mine.
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 into the different direction and
start morphing the product into something else.
And so on and then there could be another you know feedback 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.