What is a Domain-Specific Software Architecture?
1. An Architecture Style
Different kinds of problems lend themselves to different styles, idioms or
paradigms of design, analysis and implementation (e.g. object-oriented,
block diagram, concurrent processes). An architecture style captures
common computation and communication paradigms used to address a particular
class of programming problems. Various
software architecture styles have
various strengths and weaknesses, and different styles make it easier or
harder to deal with different kinds of issues.
We believe a mature and formal architecture style should possess three
basic elements:
- a well-defined notation for capturing architectures developed in that style
- well-defined methods for producing and analyzing formal models
from a specification captured in the notation
- a well-defined method for producing an implementation
from a specification captured in the notation
A style provides precise semantics for architecture diagrams, which is to
say a style defines the meanings of the various kinds of connections that
can be drawn between functional components. The associated analysis
methods allow properties of an architecture specified in that style to be
evaluated and verified, where the properties that can be analyzed depend on
the style. An architecture style defines relationships between the
elements of an architecture specification and the underlying formal
models and code modules.
An architecture style provides interface coding guidelines for source
modules intended to be used in architectures exhibiting that style, and a
style provides well-defined methods for assembling components to
produce an overall implementation.
We have several examples of families of architecture styles that are useful
in embedded systems to help explain these ideas:
Complex systems can rarely be easily and thoroughly specified and analyzed
using a single style. Instead, it is usually necessary to develop a composite
architecture style that includes a description of how two or more basic styles
can be combined together. We have several examples of ways that different
styles can be composed.
A specific architecture style can ultimately be embodied in a specific syntax
and semantics for a language used to specify architectures built according to
that style. A survey of architecture
specification languages reveals some basic architecture language
principles that seem to underly many such specification languages. This
underlying commonality can be used to facilitate the tailoring or development
of architecture specification languages and toolsets for specific styles and
application domains. These principles are illustrated by the specific ControlH and MetaH architecture languages we
have developed.
2. A Library of Reusable Functional Modules
A library of reusable source modules is one of the assets used in
architecture-based development. An architectural approach provides guidelines
to help categorize and code modules to increase their reusability. The
library is organized according to the categories of functional modules that
frequently appear in software architecture specifications for a given product
family. An architecture provides interface coding guidelines that, when
followed, allow source modules to be developed that "plug in" an
architecture with minimal modification.
3. Reusable Architecture Diagrams
For a particular family of products, one or more reusable software
architecture specifications are developed. The production of each software
product begins with the reusable software architecture, which is tailored and
filled in as needed to meet the requirements and constraints of each
individual product. A reusable software architecture is a diagram, many of
whose functional components can be found in the reuse library, and where the
meanings of the notations in that diagram are precisely defined by the
architecture style. We have an example of a reusable architecture captured
in each of the styles we listed above: