We present a user interface for software reuse repository that relies both on the informal semantics of faceted classification and the formal semantics of type signatures for abstract data types. The result is an interface providing both structural and qualitative feedback to a software reuser

Eichmann, David A.

English

NASA Technical Reports Server

- r
w
w
,i
at_
N
_J
w
7_
N93-12386
A Hybrid Approach to Software Repository Retrieval:
Blending Faceted Classification and Type Signatures
D. Eichmann
Dept. of Statistics and Computer Science
West Virginia University
Morgantown, WV 26506
email: eichmann@ a.cs.wvu.wvnet.edu
Abstract
We present a user interface for a software reuse reposi-
tory that relies both on the informal semantics of faceted
classification and the formal semantics of type signa-
tures for abstract data types. The result is an interface
providing both structural and qualitative feedback w a
software reuser,
1. Introduction
The importance of software reusability as a subdis-
cipline of software engineering is easily demonstrated
by recent publications in the area, including a substan-
tial two--volume collection edited by Biggerstaff and
Perlis [2,3], as well as the earlier collection edited by
Tracz [18].
Our current research focuses on composition-based
reuse rather than generation-based reuse [4], since we
feel that this is an area that promises the best shon term
results. As repositories increase in size and the compo-
nents contained within them increase in complexity, in-
creasing demands are placed upon the reuser, and
thereby the retrieval mechanism, to discriminate be-
tween large numbers of candidate components. This
paper discusses one such retrieval mechanism.
• i
ples of works generate a set of descriptive terms subse-
quendy organized for use in clustering the set of works
as a whole.
2.1.2. Conceptual Closeness
The vocabulary of terms built up through lit_-,_ry war-
rant typically contains a great deal of semanti: overlap,
words whose meanings are the same-or at lea.c:simitar.
For instance, two components, one implerr_nting a
stack and the other a queue might both be chz.'-z:terized
with the word insen corresponding to push and en-
queue, respectively.
Synonym ambiguity is commonly resolved tL"ough the
construction of a restricted vocabulary, ti_ '.-,:.l.v con-
trolled by the repository administrators. Repc-.'i:ory us-
ers must learn this restricted vocabulary, or r--ly upon
the assistance of consultants already familiar _ ith it. It.
is rarely the case, however, that the choice is between
two synonyms. More typically it is betw_: wor_s
which have similar, but distinct meanings.
The words in the two pairs (insen, push) and (it.sen, en-
queue) are conceptually close, that is, they both are
plausible charactezizations of one of the operations for
each of their respective components, and yet they have
distinct def'mitions in normal English usage. This fur-
ther leads to the nodon that the word pair (push, en-2. Background
This work draws from three areas of previous work: fac-
eted classification, algebraic specification, and type in-
ference.
2.1. Faceted Classification
Faceted classhqcadon was ftrst proposed as a retrieval
mechanism by Prieto--Diaz [14], and subsequently used
in at least two repository efforts [1, 10]. The technique
is founded upon the notion of literary warrant.
2.1.1. Liter'a_ Warrani
Literary warrant is a technique used in library science
for the classification of texts [19]. Representative sam-
queue) should similarly be conceptually cio_, if only
transitively through the common word insert.
Attaching a weight from the interval (0,1) sarpports a
closeness metric for word pairs, and additionally sup-
ports transitive weights as the product of the weights in-
volved. For example, we might associate a weight of .8
to the pair (insert, push) and .9 to the pair (insert, en-
queue), and thus a weight of .8 * .9 = .72 to the pair
(push,enqueue).
Note that transitive closeness of conceptually close
pah-s results in a conceptually close pair, and transitive
closeness of distant pairs results in an even rno_ distant
pair. Thus, the choice of the weights is critically impor-
PRECEDING PAGE
236 Third International Conference on Software
Engineering and Knowledge Engineering, Skokie, IL,
June 27-29. 1991, pages 236-240.
BLANK NOT FILMED
https://ntrs.nasa.gov/search.jsp?R=19930003198 2020-03-17T10:26:58+00:00Z
tam to the success and udlity of a user interface incorpo-
rating conceptual closeness.
can be deduced using the available inference rules, oth-
erwise it is ill-typed.
2.1.3. Lattice-Ba_:l Faceted Classification
Eichmann and Atkins [6] described an approach to fac-
eted classification that focused upon a sn'uclanal frame-
work (type lattices) as an alternative to explicit close-
ness weights. Each component possesseA one ot more
tuples characterizing it, each comprised of a non--empty
set of facet values. Users posed queries as mples, and
reuse candidates were retrieved based upon their con-
formance to the query tuple.
3. A Hybrid Approach
The approach advocated here combines the semantic
flexibility of faceted classification with the structural
formality of type signatures. We accomplish thi_
through the i.nco_tion of function and abstract data
type(ADD definitionsintothetypelatticeof[6].
2.2. Type Signatures
An algebraic specification contains both a syntactic
characterization of a component (the signature) and a
semantic characterization of a component (the axioms).
Algebraic specifications therefore are aptly suited as
formal descriptions of software components.
Traditional efforts in reuse concentrated on the struc-
tural interfaces between components [1, 2], and hence
solely on the signature po_on of the specification. This ..............
proved less than adequate fo? component discrimina-
tion, in the face of numerous candidate components, all
with the same interface, and directly prompted the work
in faceted classification described above.
2.3. Type Inference
Recent research in programming language has resulted
in a number of languages that are strongly typed, and
yet, are flexible and remarkable expressive, (e.g., NIL
[13]). Such languages rely heavily on inferential
mechanismstoensuresafecomputation[5,12].The
conceptofconformanceisparticularlyelevanttosoft-
ware repository query mechanisms [11]. Conformance
allows one type instance to be treated as if it were an in-
stance of another type, and can hold for arbitrary types,
regardless of the type ordering _¢me (e.g., inheri-
tance).
Type inference notation organizes around a set of infer-
ence rules, comprised of sets of premises and conclu-
sions, separated by a horizontal line. The symbol A rep-
resents an existingsetofassumptions.A alwayscon-
tainsthetypeinformation generatedby thedatabase
schemaimplementingtherepository.A xdenotesthe
set of assumptions extended with some fact x. A I- x
states that given a set of assumptions A, and the cur-
rently defined set of inference rules, x can be inferred.
An expression is well-typed ifa type for the expression
3.1. The Type Lattice
As shown in figure 1, there are four principle sublanices
comprising the complete type lattice, corresponding to
the types generated by facet sets, tuplcs, functions and
ADTs. In addition, the universal type, T, and the void
type, .L, ensure that a least upper bound and a greatest
lower bound, respectively, exist for _)' t-wo-_sin the
lattice. The usual built-in types (e.g., integers, strings,
etc.) are not shown,in order to simplify the presenta-
tion. In principle, they can be specified as ADTs if
needed.
T
Faceto d. _ T 3E.E ( }
I I ! I
I _ ! 1
i i i i
Facet T--_ _L ADT tuple
1
Figure I.
Faceto characterizes the empty generic facet type; it
contains no values, but is still a facet. Likewise, Facet
characterizes the set of all possible facet values. The
dotted line indica_s an arbitrary number of intermedi-
ate types.
The tuple sublattice has a similar structure. At the top is
the empty tuple type, {}, characterizing a type with no
components. At the bottomisTuple, the tuple type with
all possible components.
F_CtJ_ _ _bouniff.dabove by .1._ T, the func-
tion type with a void domain and universal range, and
arebounded below by T _ &,-the function type with a
universal domrlin and void range.
237
l
-I
l
1
m
I
_m
I
I
I
lI
F
W
i
I@
I
I
. =
r
rr,t.,;
w
w
w
A.DT types ate bounded above by 3_.E,the abstract type .....
denoting a a hidden type, ¢, with no information or op-
erations available, and are bounded below by ADT, the
type denoting all possible types with all possible opera-
tions.
3.2. Inference Rules
As in [6], we characterize facets as the inverse of our
usual notion of interval subtypes; a facet subtype de-
notes a larger collection of facet values than does its su-
pertype. Inference rule (1) formalizes this for a com-
plete facet.
A_m_t
A I-n_ t (l)A_m_<n
A _t -<tim...,0
Inference rule (2) does likewise for two singleton inter-
vals, and inference rule (3) for two arbitrary collections
of intervals.
A_mat
A_m'et
AI-n_t (2)A t-n'E t
A _m'<m<n<n"
A I- t(m:...') 5 tOm...n)
A I- t¢._...m)5 t(ml'...m5
A I- t ¢.=.,..,, )5t(_.,:..,,5 (3)
A t- t(m_...n_....m,...,,)5 t(mf...m'....m,'...n,_
A number of inference rules no presented here address
the reduction and manipulation of intervals [6].
3.3.1. Tuples
We view a tuple r to be of type record, {aa: t_..... a.: h},
whereattributeaAso ftypet_.Weassumethat _issome facet,
function,orADTtype.Sinceauributesarelabeled,eompo-
nentsmayappearinanyorder,andtwotypesareassumedto
beequivalem fftheyonlydifferin theorderoftheirrespec-
tive attributes.
Inference rule (4) characterizes subtyping for tuples.
Informally, one tuple type is a subtype of another if it
has all of the attributes of the other (and possible more),
and for those common attributes, the type of a given at-
tribute in the tuple subtype must be a subtype of that at-
tribute's type in the tuple supertype.
Akl<m<n
- A I-t'l 5tl
A I- t'= ._tm (4)
A I- [il : t'l ..... i= : t'_ ..... i. : t.}
-_ {i:tl ..... i_:tm}
Inference rules (5) and (6) support definition of tuple
constants and exwaction of an attribute value, respec-
tively.
A I-et= tl
A I-_= tn (53
A.(r = {il -- el ..... i. = _})
I-r: {il:t_ ..... i.:t,}
A t-r : {it : t,...h: t_}
A I- l_<j < n (6)
A t-r.i_ : tj
3.3.2. Functions
Function types ate useful both for characterizing pro-
grams and for characterizing the operations of ADTs.
Inference rule (7) characterizes the usual notion of
lambda abstraction, where x is the parameter, t' the pa-
rameter's type, e is the body of the function, and t the
type of the function's result.
A,x :t'_e:t
(7)
A I-k(x : t') e : (t" ---_t)
One function type, s -o t. is a subtype of another, s' --o t',
if the subtype function accepts the entire domain of the
function supertype (i.e., s' 5 s), and produces a range
contained in the supenype range (i.e., t-<t'), as shown in
inference rule (8).
A_s'._s
A _t St" (8)
A I-s--o t .-¢s"---_t'
Function subtyping seems a little strange at first, but a
simple example helps. Assume that f is a function type
(1..4) _ true and g is a function type (2..3) --o
(lrue..false). Function type f is a subtype of g, Any in-
stance off can always replace an instance of g in an ex-
pression without effecting the type-safety of the ex-
pression. The instance of f handles at least the values
the supertype function does, and produces no more val-
ues than does the supertype function.
Inference rule (9) characterizes the type of the result of a
function application; if the expression supplied as an at-
238
r
gument is of the proper type, then the result of the func-
tion applied to that expression will be well-typed.
A )- e: (t' _ t)
A )-e': t" (9)
A )- e (e') : t
Inference rules (I0yand (1i) define t_ inference for
existential types [4]. An existential type consists of a
type variable a, representing the type, packaged with
some number (i_ ... j,) of instances of the type and/or
operations over the type.
A _el:sjl¢,
: (1o)
A I-_: s_[¢.
A I-pack (a : t in (.jl : s] ..... j, : S,))
(e, ..... e_) : 3a.(j, : s, ..... j. : s.)
A I- e" 3b.(j1" sl ..... j.: s.)
A.(x :(jl:s] ..... jn:s.))lao)-e':t (II)
A I- open e as x [a] in e' : t
A given expression ei is of type s, when t is subsgtuted
for a in s,, and serves as the implementation of the value
or operationlabeledj_intheabstractype.Thissubstitu-
tionrcsuhsinaconcretetype(i.e.,one withnotypevari-
ablcsinit)fortheexpression.The substitutiontype t
scrvcsastherepresentationftheabstractype,denoted
externallyby theexistentialvariablea.Thc actualrep-
rcsentationand the implementationsof the operations
arenot visiblexternally.
The pack operation constructs an instance of an abstract
type, and encapsulates its representation. The open op-
eration performs the converse, binding an abstract type
variable to a concrete type, and evaluating some expres-
sion in the context of the (now concrete) abstract type.
Subtyping of ADTs derives from subtyping of the type
parameters for the abstract type, Inference rule (12)
characterizes subtyping of two instances of abstract
rlpes.
A.(tt 5 t2) I- (t _<t')
A )"(3(t_ .<t2).t) 5 (3(tl 5 t2).t') (12)
Note that in addition to providing subtyping of two
ADTs, rule (12) also supports subtyping of two in-
stances of the same ADT.
Foran example of the former, 3"r" 30" 5T').T" denotes
an existential type T" generated by a type parameter T,
which must be a subtype of the existential type T'. Since
instances of abstract types are cross products of in-
239
stances and operations, T would be a subtype of T'
through additional operations. An example of this ap-
peared in [17], showing stacksand dequeues as sub-
types of queues.
For an example of the latmr, stack of integeroao) is a
subtype of stack of integer.
4. The User Interface
A query is a boolean expression containing predicates
and the opea'ators and, or, andnot. A predicate is simply
a constant of type topic. When a user issues a query, the --
query evaluator first n'eats all of the facet values in the
query as synonyms and replaces them with actual facet
values from a value/synonym relation. For example,
database, databases, data base, and dam bases might
all be replaced with database.
The evaluator then locates all of the relations in the data-
base whose type conforms to some predicate of the
query by testing the type of each relation in turn, using
the inference rules previously described. The query lap
tice space for a given predicate is bounded above by the
predicate type itseff, and bounded below by the panidon _
tuples that conform to it. For each user-specified predi-
cate, the evaluator forms the disjunction of conforming
relation tuples (with variables in each position) and then
substitutes the conjunction of the disjunction and the _-
new predicate in place of the original, user-specified I1¢
predicate. The result of evaluating this query is then a
set of component references for display and optionally. -_
retrieval from the text storage area. m,
Note that since tuples of more than a single type may be
displayed to the user, the query language is polymo- __
rphic in one of the manners discussed in [7].
5. Discussion
tt
The work described here is another in a series of experi-
mental user interfaces for software reuse repositories.
Our initial efforts concen_ted specifically on provid-
ing substructure for faccted classification [9]. This ap- -_
proach relied only upon the expertise of the classifier in
populating the repository, and as such, suffered from
what we refer to as the vocabulary problem.
The interface described here ameliorates the situation
_y sup_g as _of the-query tuple the specificia-
lion of a formal interface structure to which the compo-
nents of interest must conform.
_mmr
W
f
!
. i
r
t
amlar
W
W
=
W
L:W
V
r
m
W
L
T
m
_g
W
A parallel effort exploring the role that algebraic speci-
fication can play in repository retrieval appears in [8].
This work is concerned particularly with retrieval over
type signatures and behavioral axioms.
6. References
[1] J. Atidns, pfivam communication, 1989.
[2] T. J. Biggerstaff and A. J. Perlis, Software Reus-
ability, vol. 1 - Concepts and Models, Addison-
Wesley, New York, NY, 1989.
[3] T. J. Biggerstaff and A. J. Periis, Software Reus-
ability, vol. 2 - Applications and Experience, Ad-
dison-Wesley, New York, NY, 1989.
[4] T. J. Biggerstaff and C. Richter, "Reusability
Framework, Assessment, and Directions," IEEE
Software, vol. 4, no. 2, pages 41--49, March, 1987.
[5] L. Cardelli, "Basic Polymorphic T)q>echecking,"
Science of Computer Programming, vol. 8, pages
147-172, 1987.
[6] L. Cardelli and P. Wegner, "On Understanding
Types, Data Abstraction, and Polymorphism,"
ACM Computing Surveys, vol. 17, no. 4, pages
471-522, December 1985.
[7] D. Eichmann, Polymorphic Extensions to the Re-
lational Model, Ph.D. dissertation, Dept. of Com-
puter Science, The University of Iowa, Iowa City,
IA, August 1989.
[8] D. Eichmann, "Selecting Reusable Components
Using Algebraic Spe_il'ications," Secondlaterna-
tional Conference on Algebraic Methodology and
Software Technology (AMAST), Iowa City, IA,
May 22-25, 1991.
[9] D. Eichmann and J. Atkins, "Design of a Lattice-
Based Faceted Classification System," Secondln-
ternational Conference on Software Engineering
and Knowledge Engineering, Skokie, IL, pages
90-97, June 21-23, 1990.
[10]
[11]
[12]
[13]
[14]
[15]
[16]
[17]
[18]
[19]
E. Guerrieri, "On Classification Schemes and Re-
usability Measurements for Reusable Software
Components," SofTech Technical Report IP-256,
Sofrech, Inc, Waltham, MA 1987.
C. Horn, "Conformance, Genericity, Inheritance
and Enhancement," ECOOP-87 - Proc. Euro-
pean Conference on Object--Oriented Program.
ruing, Paris,France, pages 223--233, June 15-17,
1987.
R. Milner, "A Theory of Type Polymorphism in
Programming," Journal of Computer and System
Sciences, vol. 17, pages 348-375, 1978.
R. Milner, M. Tofz, and R. Harper, The Definition
of Standard ML, MIT Press, Cambridge, MA,
1990.
R. Prieto--Diaz, A Software Classification
Scheme, Ph.D. dissertation, Dept. of Information
and Computer Science, University of California,
Irvine, CA, 1985.
R. Prielo-Diaz and P. Freeman,"Classifying Soft-
ware for Reusability," IEEE Software, vol. 4, no.
I, pages 6-16, January, 1987.
J. V. Guttag and J. J. Homing, "The Algebraic
Specification of Abstract Data Types," Acta Infor-
matica, vol. 10, pages 27-52, 1978.
A. Snyder, "Inheritance in the Development of
Encapsulated Software Components," Research
Directions in Object-Oriented Programming, B.
Shriver and P. Wegner, eds., MIT Press,
Cambridge, MA, pages 165-188, 1987.
W. Tracz, cA., Tutorial, Software Reuse: Emerg-
ing Technology, IEEE Computer Society Press,
Los Angeles, CA, 1988.
B. C. Vickery, Faceted Classification: A Guide to
Construction and Use of Special Schemes, Aslib,
London, 1960.
u
L
'hff
2z_O
Ir
UW
m
lit
W
n
ID
_m
I
_Up
m
I
_Ur
iB
Im
im
W
!
u


A hybrid approach to software repository retrieval: Blending faceted classification and type signatures

Abstract

Similar works

Full text

Available Versions

NASA Technical Reports Server