DRAFT
Design Specification Template
Version 0.1
Provide an overview of the entire document:
- Describe the purpose of this document
- Describe this document's intended audience
- Identify the system/product using any applicable names and/or version numbers.
- Provide references for any other pertinent documents such as:
- Related and/or companion documents
- Prerequisite documents
- Documents which provide background and/or context for this document
- Documents that result from this document (e.g. a test plan or a development plan)
Define any important terms, acronyms, or abbreviations. Summarize (or give an abstract for) the contents of this document.
An ordered list of defined terms and concepts used throughout the document.
Provide a general description of the software system including its functionality and matters related to the overall system and its design.
This section should provide a high-level overview of how the functionality and
responsibilities of the system. It should also define the mapping from responsibilities to subsystems/components implementing them. This mapping should be justified here. This basically answers why the system was decomposed in such a manner.
This section should also cover:
- Describe how the higher-level components collaborate with each other in order to achieve the required functionality.
- Describe the use of architectural strategies (e.g. design patterns) referring to those components using them.
Diagrams should be used here. Note: Resist the temptation of going into too much detail here, this section should only deal with architectural aspects.
This section can be repeated as many times as needed. It should be used for discussing components that are complex enough from an architectural point of view. The contents here are similar the System Architecture section above. This section can also be recursively subdivided if needed.
This section describes policies that does not have a profound impact on the system architecture or design. However, such policies affect the details of development at different phases. Descriptions of the following policies should be described in this section:
- Coding guidelines and conventions
- Plans for ensuring requirements traceability
- Plans for testing the software
- Plans for maintaining the software
- Hierarchical organization of the source code into its physical components (files and directories).
- How to build and/or generate the system's deliverables (how to compile, link, load, etc...)
Each subsection of this section will refer to or contain a detailed description of a system software component.
This subsection will be repeated a number of times equal to the number of class in the system. For each class, provide the following information:
- Class Name
- Component(s) Name that this class serves/part of.
- File(s) where it resides physically
- Definition: A precise definition of what it means to have an object of this type living in the system.
- Composition: A description of the underlying structure of the class. [This can be pinned down to data structure specification].
- Collaborations: A description of the class collaborations with other
classes/client programs. What other classes is this entity used by? What
other classes does this entity use (this would include any side-effects this
entity might have on other parts of the system)?
- Interface: A description of each service provided by the class to the
outside world (the rest of the system). Pre/post-conditions for each service
should be specified. The constructors, destructors, and private methods should
not be discussed here.
- Processing: A description of how the class carries out its responsibilities. This should encompass a description of any algorithms used, changes of state, methods of creation/initialization, cleanup, and handling of exceptional
conditions.
A list of referenced and/or related publications.
Roby Jose
2003-07-28