software+design+outline

toc

Document Outline
What follows is just one suggested outline format to use when attempting to present the architecture and design of a system. The outline is by no means exclusive. A particular numbering scheme is not necessarily required and you are //more// than welcome to add your own sections or subsections where you feel they are appropriate.
 * Introduction
 * System Overview
 * Design Considerations
 * Assumptions and Dependencies
 * General Constraints
 * Goals and Guidelines
 * Development Methods
 * Architectural Strategies
 * strategy-1 name or description
 * strategy-2 name or description
 * System Architecture
 * component-1 name or description
 * component-2 name or description
 * Detailed System Design
 * module-1 name or description
 * module-2 name or description
 * module-1 name or description
 * module-2 name or description

Introduction
Provide an overview of the entire document:
 * Describe the purpose of this document
 * Describe the scope 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.

System Overview
Provide a general description of the software system including its functionality and matters related to the overall system and its design (perhaps including a discussion of the basic design approach or organization). Feel free to split this discussion up into subsections (and subsubsections, etc ...).

Design Considerations
This section describes many of the issues which need to be addressed or resolved before attempting to devise a complete design solution.

Describe any assumptions or dependencies regarding the software and its use. These may concern such issues as:
 * Assumptions and Dependencies**
 * Related software or hardware
 * Operating systems
 * End-user characteristics
 * Possible and/or probable changes in functionality

Describe any global limitations or constraints that have a significant impact on the design of the system's software (and describe the associated impact). Such constraints may be imposed by any of the following (the list is //not// exhaustive):
 * General Constraints**
 * Hardware or software environment
 * End-user environment
 * Interface/protocol requirements
 * Data repository requirements
 * Security requirements (or other such regulations)
 * Performance requirements
 * Verification and validation requirements (testing)
 * Other means of addressing quality goals
 * Other requirements described in the requirements specification

Describe any goals, guidelines, principles, or priorities which dominate or embody the design of the system's software. Such goals might be: For each such goal or guideline, unless it is implicitly obvious, describe the reason for its desirability. Feel free to state and describe each goal in its own subsubsection if you wish.
 * Goals and Guidelines**
 * The KISS principle ("Keep it simple stupid!")
 * Emphasis on speed versus memory use

Briefly describe the method or approach used for this software design. If one or more formal/published methods were adopted or adapted, then include a reference to a more detailed description of these methods. If several methods were seriously considered, then each such method should be mentioned, along with a brief explanation of why all or part of it was used or not used.
 * Development Methods**

Architectural Strategies
Describe any design decisions and/or strategies that affect the overall organization of the system and its higher-level structures. These strategies should provide insight into the key abstractions and mechanisms used in the system architecture. Describe the reasoning employed for each decision and/or strategy (possibly referring to previously stated design goals and principles) and how any design goals or priorities were balanced or traded-off. Such decisions might concern (but are not limited to) things like the following:
 * Use of a particular type of product (programming language, database, library, etc. ...)
 * Reuse of existing software components to implement various parts/features of the system
 * Future plans for extending or enhancing the software
 * User interface paradigms (or system input and output models)
 * Hardware and/or software interface paradigms
 * Error detection and recovery
 * External databases and/or data storage management and persistence
 * Concurrency and synchronization

Make sure that when describing a design decision that you also discuss any other significant alternatives that were considered, and your reasons for rejecting them (as well as your reasons for accepting the alternative you finally chose). Sometimes it may be most effective to employ the "pattern format" for describing a strategy.

System Architecture
This section should provide a high-level overview of how the functionality and responsibilities of the system were partitioned and then assigned to subsystems or components. Don't go into too much detail about the individual components themselves (there is a subsequent section for detailed component descriptions). The main purpose here is to gain a general understanding of how and why the system was decomposed, and how the individual parts work together to provide the desired functionality.

At the top-most level, describe the major responsibilities that the software must undertake and the various roles that the system (or portions of the system) must play. Describe how the system was broken down into its components/subsystems (identifying each top-level component/subsystem and the roles/responsibilities assigned to it). Describe how the higher-level components collaborate with each other in order to achieve the required results. Don't forget to provide some sort of rationale for choosing this particular decomposition of the system (perhaps discussing other proposed decompositions and why they were rejected). Feel free to make use of design patterns, either in describing parts of the architecture (in pattern format), or for referring to elements of the architecture that employ them.

If there are any diagrams, models, flowcharts, documented scenarios or use-cases of the system behavior and/or structure, they may be included here (unless you feel they are complex enough to merit being placed in the Detailed System Design section). Diagrams that describe a particular component or subsystem should be included within the particular subsection that describes that component or subsystem.

If a particular component is one which merits a more detailed discussion than what was presented in the System Architecture section, provide that more detailed discussion in a subsection of the System Architecture section. If necessary, describe how the component was further divided into subcomponents, and the relationships and interactions between the subcomponents (similar to what was done for top-level components in the System Architecture section).
 * Subsystem Architecture**

If any subcomponents are also deemed to merit further discussion, then describe them in a separate subsection of this section (and in a similar fashion). Proceed to go into as many levels/subsections of discussion as needed in order for the reader to gain a high-level understanding of the entire system or subsystem (but remember to leave the gory details for the Detailed System Design section).

Detailed System Design
Most components described in the System Architecture section will require a more detailed discussion. Other lower-level components and subcomponents may need to be described as well. //Each subsection of this section will refer to or contain a detailed description of a system software component.// The discussion provided should cover the following software component attributes:

> > > > > > > >
 * //Classification// The kind of component, such as a subsystem, module, class, package, function, file, etc. ....
 * //Definition// The specific purpose and semantic meaning of the component. This may need to refer back to the requirements specification.
 * //Responsibilities// The primary responsibilities and/or behavior of this component. What does this component accomplish? What roles does it play? What kinds of services does it provide to its clients? For some components, this may need to refer back to the requirements specification.
 * //Constraints// Any relevant assumptions, limitations, or constraints for this component. This should include constraints on timing, storage, or component state, and might include rules for interacting with this component (encompassing preconditions, postconditions, invariants, other constraints on input or output values and local or global values, data formats and data access, synchronization, exceptions, etc.)
 * //Composition// A description of the use and meaning of the subcomponents that are a part of this component.
 * //Uses/Interactions// A description of this components collaborations with other components. What other components is this entity used by? What other components does this entity use (this would include any side-effects this entity might have on other parts of the system)? This concerns the method of interaction as well as the interaction itself. Object-oriented designs should include a description of any known or anticipated subclasses, superclasses, and metaclasses.
 * //Resources// A description of any and all resources that are managed, affected, or needed by this entity. Resources are entities external to the design such as memory, processors, printers, databases, or a software library. This should include a discussion of any possible race conditions and/or deadlock situations, and how they might be resolved.
 * //Processing// A description of precisely how this components goes about performing the duties necessary to fulfill its responsibilities. This should encompass a description of any algorithms used; changes of state; relevant time or space complexity; concurrency; methods of creation, initialization, and cleanup; and handling of exceptional conditions.
 * //Interface/Exports// The set of services (resources, data, types, constants, subroutines, and exceptions) that are provided by this component. The precise definition or declaration of each such element should be present, along with comments or annotations describing the meanings of values, parameters, etc. .... For each service element described, include (or provide a reference) in its discussion a description of its important software component attributes (Classification, Definition, Responsibilities, Constraints, Composition, Uses, Resources, Processing, and Interface).

Provide a detailed description of this software component (or a reference to such a description). Complex diagrams showing the details of component structure, behavior, or information/control flow may be included in the subsection devoted to that particular component (although, unless they are very large or complex, some of these diagrams might be more appropriately included in the System Architecture section. The description should cover any applicable software component attributes (some of which may be adequately described solely by a source code declaration or excerpt).
 * Detailed Subsystem Design**


 * //Addapted from Brad Appleton's web site//** //[|http://www.bradapp.net]//