|
Once an overall design and architecture is complete (or
mostly done), individual developers will be assigned
various modules to build. Their first steps are to
design and build the module unit tests, which is described
here and here.
After the tests are designed and built, the module can be
designed. Again, developers should design and build
the tests first, as this forces them to think long and
hard about the issues surrounding the module before they
actually design and build it.
A detailed design is simply the next layer in the
design process, taking up where the overall design and
architecture leaves off. It includes a class diagram
for all module classes that includes properties and
methods, plus pseudo-code for all methods. This
pseudo-code will vary in detail, from super simple for
trivial methods to fairly complex for larger methods.
It's important to understand the purpose of the design
review, which is to look at the detailed design and flow,
thus five lines of pseudo-code does not realistically
represent a 500 (or even 50) line method. In particular,
pseudo-code should cover all decision making, flow
control, looping, and error handling in a method or
function.
Interaction or flow diagrams may also be necessary,
showing how the classes interact with each other and how
errors are handled (especially how they are unwound).
If an MVC architecture is being used, this is where the
detailed interactions are worked out, especially the exact
controller operation, as this is where some major
abstraction mistakes can be made. In addition, the
model details are outlined at this level, both to settle
on the abstraction models and to simply lay out the model
algorithms. View must be delineated along with all
of their possible gestures.
|
|