Software is quickly becoming integral part of human life as we see more and more automation and technical advancements. Just like we expect car to work all the time and can't afford to break or reboot unexpectedly, software industry needs to continue to learn better way to build software if it were to become integral part of human life. In this course, you will get an overview of how software teams work? What processes they use? What are some of the industry standard methodologies? What are pros and cons of each? You will learn enough to have meaningful conversation around software development processes. After completing this course, a learner will be able to 1) Apply core software engineering practices at conceptual level for a given problem. 2) Compare and contrast traditional, agile, and lean development methodologies at high level. These include Waterfall, Rational Unified Process, V model, Incremental, Spiral models and overview of agile mindset 3) Propose a methodology best suited for a given situation
Software Development Models
Loading...
來自 University of Minnesota 的課程
Software Development Processes and Methodologies
198 個評分
Explore Related Videos
At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you
從本節課中
Software Development Models: Traditional Models
In this module we will learn about various traditional models like waterfall, RUP, Incremental, and Spiral models.
與講師見面
Praveen MittalAdjunct Professor
College of Science and Engineering
Kevin WendtTeaching Specialist
Department of Computer Science and Engineering
[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.
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 you wanted 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 for
us 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 model.
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 in 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.
