A Distributed Component Software Development Process

1
A Distributed Component Software Development
Process

• Andrew Olson
• Department of Computer Information Science
• IUPUI
• May, 2001

2
The Problem

• Construct software from existing components to
  meet specified requirements.
• A distributed, heterogeneous network supplies
  components with published quality of service
  statements.
• The resulting software would be a distributed
  software system (dss).

3
Benefits

• Reuse of up-to-date technologies.
• Conserves human resources.
• Accelerates delivery.
• Reduces effort necessary to assure quality.
• Product can be made available as a component on
  the network.
• Product can be embedded in existing environment
  of components.
• Cheap components trade for expensive construction
  costs.

4
Difficulties

• A required component may not be available under
  appropriate conditions.
• There may exist no solution to the problem in the
  network.
• The necessary knowledge to construct the solution
  may not become evident to the software engineer.
• The required quality for the product may not be
  achievable
• The number of iterations in the process may be
  too great for feasibility.
• Component and construction costs may exceed
  resources.

5
An Iterative, IncrementalSoftware Development
ProcessA High-level Description
6
Repeat Analyze problem domain for new
knowledge. Formulate problem domain model in
terms of intended uses of desired dss.
Prioritize the use cases, j 1, 2, N.
Write Quality_of_Service statement these use
cases collectively require. Let P be the
parameters in Quality_of_Service. For j
1,..., N Develop problem domain model
in the context of use cases i 1, 2,..., j.
From domain model, develop formal
DesignSpec_j for a dss that
responds use cases 1, 2,...,j. Choose
from available components the set, A, to use
in constructing the dss according to
DesignSpec_j. Implement( DesignSpec_j,
A Complex_j ), in which an assembled
software element of Complex_j has
quality of service QoS_j. End For.
Compare QoS_N with Quality_of_Service
remove the parameters it meets from P.
Modify the collection of components
considered available for use as part
of the dss to be constructed.Until P is
empty.
7
Implement !

• This is the interface to the network.
• Formulate quality of service requests for
  components.
• Follow Unified Meta-Model.
• Deal with network failure.
• Integrate components into product.

8
Implement( IN DesignSpec, Available OUT
Complex ). Success False. Repeat
Write quality requests qr_i for i in I
using DesignSpec. Determine
performance constraints PC_i Let
RequestforBid_i( PC_i, qr_i ) for all i in I.
Publish RequestforBid_I for i in I,
following UMM meta-model. If there
is i in I for which RequestforBid_i is
NOT met, extract more
information from DesignSpec if possible.
Else result is set of classes c_i for
i in I that satisfy qr_i for i in I.
Integrate( DesignSpec, c_i ,
Available Complex ). Success
True. End If. Until Success OR All
DesignSpec information has been used. If NOT
Success, set Complex empty.End Implement.
9
Integrate !

• Purge Component Classes
• Validate components against requirements.
• Build
• Use the Design Specification, Available
  components, Compliant Classes.
• Construct a dss Complex with a specific Quality
  of Service.

10
Purge( IN c_i , s_i OUT
CompliantClasses ). For each i in I Let
C c_i. Repeat Select a
representative c in C. Validate c
against the specification s_i. If c
fails, remove it from C. Until all c in C
have been validated. If C is empty, then
Let design_spec s_i, _, _ .
Implement( design_spec, _ complex_i ),
where
complex_i ( c_i, qos_i ). Let C
c_i. End If. Let c_i C.
Remove any duplicates from c_i. End For.
Let CompliantClasses c_i for i in I.End
Purge.
11
Build !

• This is the principle activity of Implement.
• SelectVerify forms component structure, verifies
  against design specs. and obtains QoS.
• If not verified, defines design specs. for
  substructure. Calls Implement substructure.
• Builds a structure from substructure and retained
  components.
• Verifies with event traces discards failures.
• Repeats for all possible component combinations.
• Determines class of structures with maximal QoS.

12
Design Specifications

• DesignSpec s_i, r_j, a_k , in which
• for each i in I 1, 2, m, s_i is a
  requirements
• specification for a component, c_i,
•   for each j in J 1, 2, , n, r_j is a
  relation among
• components satisfying s_i for i in I,
  and
• for each k in K 1, 2, , p, a_k is an
  assertion on
• components satisfying s_i, for i in I,
  and relations
• r_j, for j in J, i.e.,
  a_ks_i?r_j?True, False.

13
SelectVerify(IN DesignSpec, CombinationSpace,
Available OUT Success,
Structure, UnsatisfiedConstraints). Let
DesignSpec s_i, r_j, a_k . Suppose
c_1xc_n CombinationSpace. For each i
in I, select c_i in c_i. Form
Structure Available, c_i, r_j
according to the relations r_j
for j in J. Using event traces, verify
which of the constraints a_k for k in
K that Structure satisfies. If it
satisfies all, then Success True.
UnsatisfiedConstraints is empty.
Else Success False.
Let UnsatisfiedConstraints contain each a_k that
Structure does not satisfy.
End If. End SelectVerify.
14
Build(IN DesignSpec, CompliantClasses,
Available OUT Complex).
Suppose that DesignSpec s_i, r_j, a_k
. Let W be an empty set. Let C c_1
? c_n, where c_i belongs to
CompliantClasses. . . .
15
Repeat SelectVerify(DesignSpec, C,
Available Success, S, UnsatisfiedConstraints).
Suppose S Available, c_i , r_j
and UnsatisfiedConstraint
s a_k for k in K', a subset of K. If
Success, then Determine QoS for S.
W W (S, QoS) .
/ Save structure / Else
/ Look for a good
substructure / Let c_i for i in I', a
subset of I, be those components that impact
UnsatisfiedConstraints. Then, D
s_i for i in I', r_j, a_k is a
subspecification of DesignSpec.
Implement( D, Available, c_i for i in I-I'
SubImplementation ). For each element e
in SubImplementation Suppose e (
substructure, qos ), in which substructure
c_i for i in I', r_j Using
appropriate elements of Available, and following
r_j for j in J, integrate
S Available, c_i for i in I-I',
substructure, r_j . Use event
traces to verify S satisfies DesignSpec.
If verification is successful,
Determine QoS of S. Let W W
(S, QoS) . / Save structure /
Else / Unsatisfactory combination omit S. /
End If. End For. End
If. C C - c_1 ? c_n. Until C is
empty.
16
Let t 0 and V W / Set of good
structures /. While V is not empty /
Search for maximal QoS / Let y be an
element of V. Then, y (S, QoS). If
m(QoS) gt t, then t m(QoS). V V -
y. End While. Let Complex be empty.
While W is not empty /Construct optimal
Complex/ Let y be an element of W. Then,
y (S, QoS). If m(QoS) gt t, then Complex
Complex y. W W - y. End
While.End Build.
17
Thats All !Thanks.