<- previous index next ->
"Simply elegant vs elegantly simple"
We will cover methods and techniques for:
System Architecture Design
System Decomposition
Procedural Design
Data Structure Design
Object-oriented Design
Designing to meet requirements
Designing to minimize risks
Methods of documenting a design
System Architecture Design
The Architecture includes making the requirements
specific about:
1) On what operating systems must the product run.
2) The user interface style: command line or graphical
user interface (point and click), some combination
based on the actor.
3) The implementation, if not command line, terminal
based or web based or other.
4) The language(s) that will be used
5) The tool kits or libraries or data bases that will
be used.
From specific choices of 1) through 5) a top level
single box, with a name, with requirements wording
of input and output.
System Decomposition
Now the requirements may be designed using multiple
boxes for some requirements, one box for some requirements,
several requirements in one box. Each box get a specific
name that will be traceable through coding and testing.
This may be one or mode diagrams with indication of
how they fit into the top level architecture box.
Procedural Design
For each decomposition box, the control flow may
need to be specified. Options include flow diagrams,
pseudo code, or other representations. The goal is
to have a design without having code and yet not
just the requirement.
The traditional flow diagram.
Well, this example also has some data structure definition.
Data Structure Design
Only having the procedural definition has been shown to
be insufficient to express an unambiguous design.
The data structures may be presented as tables,
or possibly, actual code. The design document will
have the full description of data structures with
name, type, and possibly where each data item comes from
and where, or by what, each data item is used.
Some of this may make its way into comments in the
code, but do not count on this.
From a syntax view a_routine(data_object)
An example of plain C, red-black-trees
tree_rb.c
tree_rb_c.out
Object-oriented Design
The Object Oriented includes the Procedural and
Data Structure Designs encapsulated where the procedural
just operates on the specified data structures.
From a syntax view data_object.a_method()
An example of Java, different red-black-trees
RedBlack.java
RedBlack_java.out
Designing to meet requirements
This will typically be a top down design.
The first step is to go through all requirements and
determine the necessary architecture.
Designing to minimize risks
Rapid prototyping of small parts is important.
This shows your team can implement what your
team is designing.
I suggest, for this course, you do not use
a new language or library, etc. that no one
on your team has used previously.
Methods of documenting a design
All of the above. Diagrams, text, tables.
See SDD.doc for your next document
<- previous index next ->