To make this a little more concrete, let's look at
an example involving cycles, phases, and iterations. Let's assume that we
have to develop a banking IT system. The first possible
cycle for such a system could be one in which we
implement the basic withdrawal facilities. What this means is that,
at the end of this cycle, there will be the release
of the product that implements this piece of functionality. But notice
that this will not be the only product release because within
the cycle, we will perform also the four phases that
we mentioned before, inception, elaboration,
construction, and transition. And within each
of these phases, we might have multiple iterations. And at the
end of each iteration, we will also have a product release.
Which in this case, will be an internal one. As
you can see, the iterative nature is really inherent in the
unified rational process. So, now let's clean up here, and let's
see what some other possible cycles could be for our banking
IT system. Here, I'm showing two possible additional ones. The first
one, cycle two, which will develop the account and system management. And
the third one, cycle three, which will develop the full account
management and cross selling. Similarly to cycle one, also these cycles will
produce a product, both at the end of the cycle, and
within the cycle in the different phases. And there's a few more
things to note. So the first one, is that each cycle
focuses on a different part of the system. So what you will
do, when you use the rational unified process, you will select a
subset of use cases that you want to realize within your cycle.
And the final product for that cycle, will be a product that
realizes those use cases. This is the first aspect. The second one,
is that these cycles, as you can see, are slightly overlapping. So
it is not the case that you finish a cycle, and then
you start the next one. So there is a little bit of
overlap among cycles, and we'll talk about that more. And finally,
I want to stress one more that each cycle
contains four phases, and each one of these phases might
be further splayed in iterations. So that's kind of a
high level view of how the whole process will work.