The next process model I want to discuss is evolutionary
prototyping, which works in four main phases. We start
from an initial concept, then we design and implement
a prototype based on this initial concept, refine the prototype
until it is acceptable, and finally we complete and
release the prototype. Therefore, when developing a system using
evolutionary prototyping, the system is continually refined and rebuilt.
So it is an ideal process when not all requirements
are well understood. Which is a very common situation. So, looking
at this in a little more details, what happens is that
developers start by developing the parts of the system that they
understand, instead of working on developing a whole system, including parts
that might not be very clear at that stage. The partial
system is then shown to the customer and the customer feedback
is used to drive the next iteration, in which either changes
are made to the current features or new features are added.
So, either the current prototype is improved or the
prototype is extended. And finally, when the customer agrees that
the prototype is good enough, the developers will complete all
the remaining work on the system and release the prototype
as the final product. So let's discuss as we did
for the previous process models, what are the main advantages
and disadvantages of evolutionary prototyping. In this case, the main
advantage is the immediate feedback. Developers get feedback immediately as
soon as they produce a prototype and they show it to
the customer and therefore, the risk of implementing the wrong system is
minimized. The main negative is the fact that it's difficult to plan.
When using evolutionary prototype it is difficult to plan in advance how
long the development is going to take, because we don't know how
many iterations will be needed. And another drawback is that it can
easily become an excuse to do kind of do cut and fix
kind of approaches in which we hack something together, fix the main
issues when the customer gives us feedback, and then continue this
way, until the final product is something that is kind of
working, but it's not really a product of high quality. Something
else I want to point out before we move to the next
software process model is that there are many different kinds of
prototyping, so evolutionary prototyping is just
one of them. For example, throwaway
prototyping is another kind of prototyping in which the prototype is
just used to gather requirements, but is thrown away at the end
of the requirements gathering, instead of being evolved as it happens here.