In this paper, we have primarily described the models that we build for software design, and have made only passing references to the process by which those models are constructed. It is important to understand that although information conceptually flows through the models from essential use cases to the system object and then into the internal object-oriented design, we are describing a philosophical view of the relationships between these design models, and not a temporal or process view of the way the models should be constructed. In particular, we do not practice or advocate a waterfall approach, beginning with essential use cases for ``analysis'', then making sure they are ``complete'' and ``correct'' before proceeding onto the next phase of ``design'', and so on.
Rather, we expect that the design process will be incremental and iterative: starting by coming up with a list of candidate use cases, and developing a rough domain model in parallel. Then, some focal use cases could be elaborated, identifying user intentions and system responsibilities and writing them onto use case cards. An initial design could be developed for these use cases, resulting in responsibilities being tracked backwards from objects and the wording of the use cases being refined. Then more use cases could be elaborated, more object modeling attempted, existing work revisited in the light of later developments, and so on, as is accepted good practice.
We have found that using essential use cases and responsibilities throughout the whole design iterative development rather than hindering it. Common levels of abstraction and a common vocabulary between use cases and objects make it easier to work either forwards or backwards during an iteration, tracing use cases to objects or vice versa. This also makes it easier to answer the frequently-asked question about when a design is complete [20]: the design is done when all the use cases and objects use the same vocabulary, when all the system responsibilities have been delegated to internal objects within the design, and when every use case can be executed by the object model.