The proposed Domain Engineering process consists of the following steps:
- Stage 1
- Define/Scope the Domain
- Stage 1.1
- Define goals of domain modeling.
- Stage 1.2
- Define the domain.
- Stage 1.2.1
- Identify what is inside the domain.
- Stage 1.2.2
- Identify what is outside the domain.
- Stage 1.2.3
- Identify what is on the borders of the domain
(input/output).
- Stage 1.3
- Define Domain Specific Resources
- Stage 1.3.1
- Define who you have to work with.
- Stage 1.3.2
- Define what you have to work with.
- Stage 1.3.3
- Define how you will verify the models.
- Stage 1.4
- Define the domain of interest (subset of
work that could be done).
- Stage 2
- Define/Refine Domain Specific
Concepts/Entities/Requirements
- Stage 2.1
- Define a block diagram architecture (E/R Diagram).
- Stage 2.1.1
- Identify concepts/entities (behavior, temporal,
and data) in the domain.
- Stage 2.1.2
- Identify attributes of concepts/entities.
- Stage 2.1.2.1
- Identify required/essential/mandatory
concepts/entities.
- Stage 2.1.2.2
- Identify optional concepts/entities.
- Stage 2.1.2.3
- Identify alternative concepts/entities.
- Stage 2.1.2.4
- Identify requirements common from
application to application
- Stage 2.1.2.5
- Identify requirements that vary from
application to application.
- Stage 2.1.3
- Identify relationship between concepts/entities.
- Stage 2.1.3.1
- Identify ``is a/a kind of'' relationships
between concepts.
- Stage 2.1.3.2
- Identify ``consists of'' relationships
between concepts.
- Stage 2.1.3.3
- Identify ``uses/needs'' relationships
between concepts.
- Stage 2.1.4
- Classify and cluster common concepts.
- Stage 2.1.5
- Record issues, trade-offs, and rationale.
- Stage 2.1.6
- Create a Domain Description Document.
- Stage 2.2
- Create a Domain Vocabulary Dictionary.
- Stage 2.2.1
- Create a Domain Thesaurus (list of synonyms).
- Stage 2.3
- Create a High-Level Requirements Specification
document.
- Stage 2.4
- Refine concepts/entities already identified to reflect
desired level of detail.
- Stage 3
- Define/Refine Domain Specific Implementation
Constraints.
- Stage 3.1
- Define general implementation constraints on the
architecture.
- Stage 3.1.1
- Define general software constraints (e.g.,
programming language, run-time system, or
Operating System)
- Stage 3.1.2
- Define general hardware/physical constraints
(e.g., platform, sensors, or appearance).
- Stage 3.1.3
- Define general performance constraints (e.g.,
response time, accuracy).
- Stage 3.1.4
- Define general mission constraints (e.g., fault
tolerance, security, or safety).
- Stage 3.2
- Identify relationships between concepts and constraints.
- Stage 4
- Develop Domain Architectures/Models.
- Stage 4.1
- Define a Domain Specific Software Architecture or
Architectures.
- Stage 4.1.1
- Define a decision taxonomy for requirements and
constraints
for each architecture.
- Stage 4.1.2
- Record design issues, trade-offs, and decision
rationale.
- Stage 4.2
- Specify interfaces for each module (operations and
operands).
- Stage 4.2.1
- Specify semantics of each module (behavior).
- Stage 4.2.2
- Specify constraints on each module (e.g., entry/exit
criteria).
- Stage 4.2.2.1
- Specify performance/timing constraints.
- Stage 4.2.2.2
- Specify dependency (layering) constraints.
- Stage 4.2.2.3
- Specify sequentiality/order (operational)
constraints.
- Stage 4.2.2.4
- Specify mission constraints.
- Stage 4.2.3
- Specify performance characteristics of each model.
- Stage 4.2.4
- Identify configuration (generic) parameters for each
model.
- Stage 4.2.5
- Record issues, trade-offs and design rationale.
- Stage 4.3
- Link models to concepts and requirements.
- Stage 4.4
- Refine a Domain Specific Software Architecture or
Architectures to
reflect desired level of detail.
- Stage 5
- Produce Reusable Workproducts.
- Stage 5.1
- Develop the reusable artifacts (e.g., code,
documentation, test
cases, etc.)
- Stage 5.1.1
- Determine parameterization/configurability level
desired.
- Stage 5.1.2
- Implement each module.
- Stage 5.1.3
- Test each module.
- Stage 5.1.4
- Document each module.
- Stage 5.1.5
- Record issues, trade-offs and design rationale.
- Stage 5.2
- Link artifacts to models, concepts, and requirements.
- Stage 5.3
- Link documentation to models, concepts, and
requirements.