| abstract component technology |
a vocabulary and notation for specifying
components, assemblies, and their runtime environments in a
component-technology-independent way, and for specifying the constraints,
imposed by reasoning frameworks, that must be satisfied for predictions to be
valid |
| analytic
constraints |
constraints imposed by one or more reasoning
frameworks on an abstract component technology |
| annotation |
a property P associated with a referent R,
meaning that “R has property P,” denoted as R.P |
| assembly |
a set of components and their enabled
interactions |
| assembly
constraints |
behavioral and topological rules of
well-formedness imposed on components and assemblies by one or more (real)
component technologies, and one or more reasoning frameworks |
| automated reasoning
procedure |
a decision procedure and interpretation, each
susceptible to full automation. See also property theory. |
| binding label |
a linking mechanism embedded in components to
enable their interaction with other components. See also pin. |
| Communicating Sequential Processes (CSP) |
a specification language and formal notation for
describing concurrency behavior in systems. |
| component |
an implementation in final form, modulo bound
labels, that provides an interface for third-party composition and is a unit of
independent deployment |
| component technology |
a component technology imposes fabrication
standards for assembling software from large-scale building blocks. A component
technology consists of a component model and a runtime environment. The
component model specifies fabrication standards governing such issues as a
component's life cycle and allowable forms of interaction. A runtime
environment is an execution environment that enforces aspects of the component
model and provides standard interaction mechanisms and services. |
| compose |
to enable component interaction through
connectors |
| composition |
a set of interactions among components enabled
through connectors. See also assembly. |
| connector |
a mechanism provided by the runtime environment
that enforces an interaction protocol, or discipline, on the components that
are participants in an interaction |
| construction
framework |
an abstract component technology, tools to
enforce assembly constraints, and other tools used to automate the
specification, development, and deployment of components and their
assemblies |
| construction
language |
a language for specifying abstract component
technologies (ACTs) and their well-formed components and assemblies |
| counter
example |
a counterexample is an execution
trace that results in the violation of a behavioral assertion. Counterexamples
provide diagnostic feedback that help engineers understand and reproduce
failures |
| contain |
to restrict the visibility of
interactions on pins. All interactions among components are restricted to the
scope of the most immediately enclosing (“containing”) assemblies and
partial assemblies. |
| co-refinement |
a process for developing reasoning
frameworks, and in particular, for finding an acceptable tradeoff among various
qualities of a reasoning framework, such as generality, complexity, and
stability |
| decision
procedure |
a function that evaluates claims
made on assemblies, described in the property theory, to the values
“true” or “false” |
| deploy |
defines where (in which instance of
a runtime environment, and, ultimately, on which physical computing device)
component behavior is executed |
| empirical
evidence |
evidence acquired through direct
observation, preferably under controlled circumstances, with results reported
in well-defined units of measure. Empirical evidence is therefore provisional,
as any other observation might have been different. See also formal
evidence. |
| final form |
a software specification that is
ready for execution on a physical or virtual machine. See also
component. |
| formal
evidence |
evidence acquired through
mathematical proof. Formal evidence is therefore irrefutable, as all such
proofs are tautological. See also empirical evidence. |
| in the
zone |
within trusted and predictable
parameters. Components are “in the zone” are predictable before
they are built, and component assemblies are “in the zone” if their
runtime behavior is analytically predictable. |
| interaction |
a composition of two or more
reactions, from distinct components, using a runtime-environment-provided
connector |
| interpretation |
a mapping from assemblies specified
in a construction language to specifications in the language of a reasoning
framework |
| partial
assembly |
a (recursively defined) abstraction
that aggregates a set of components and their enabled interactions and exposes
selected component pins. Logically, a partial assembly is a component
implemented entirely in terms of other components. See also
assembly. |
| prediction-enabled component technology (PECT) |
a component technology that has been
extended with one or more predication-enabling technologies |
| property |
an n-tuple <name, value, ...
>, where name and value refer to the name of some property and the value
it takes, respectively. See also annotation. |
| property
theory |
a calculus and logic that provides
an objective, rigorous, and verifiable or falsifiable basis for predicting the
properties of assemblies |
| reaction |
specification of the behavior of a
unit of concurrency within a component (e.g., a thread) and the behavioral
dependencies between sink pins and source pins of a component |
| reasoning framework |
a combination of a property theory,
an automated reasoning procedure, and a validation procedure that is used to
predict assembly properties |
| pin |
a binding label in the construction
and composition language (CCL). See also source pin, sink pin,
connector. |
| runtime
environment |
environment that provides runtime
services that may be used by components in an assembly, provides an
implementation for one or more connectors, and enforces assembly
constraints |
| sink pin |
a pin that accepts
interactions with the environment of a component (i.e., from other components
or the runtime environment). See also pin, source pin. |
| source pin |
a pin that initiates
interactions with the environment of a component (i.e., to other components or
the runtime environment). See also pin, sink pin. |
| unit of independent
deployment |
a component is independently
deployable if all its dependencies on external resources are clearly specified
(e.g., as pins), and if it can be substituted for, or substituted by, some
other component. See also deployment. |
| validation
procedure |
provides an objective basis for
trusting the validity and soundness of a reasoning framework, and defines its
required component properties with sufficient rigor to provide an objective
basis for trust in assertions of component behavior |
