ftp.umcs.maine.edu/2015-02-07.ftp.umcs.maine.edu.tar/ftp.umcs.maine.edu/pub/WISR/wisr6/proceedings/ascii/castano.ascii

Text File | 1993-10-19 | 23KB | 372 lines

Castano - 1


Requirements Specification Reuse


Silvana Castano  and  Valeria De Antonellis

Dipartimento di Elettronica e Informazione
Politecnico di Milano
P.za Leonardo Da Vinci,32 - 20133 Milano - ITALY
Tel: [phone]
Email: [e-mail]
Fax: [phone]


Abstract

An environment to support reuse at the requirement specification level of
the application development lifecycle is presented.The reuse model is
introduced, and a methodology for defining reusable conceptual
components is illustrated. Finally, the architecture of the tools supporting
the reuse process is described.

Keywords: Conceptual Schema, Classification, Design-for-reuse, Design-
by-reuse, Requirements Reuse, Requirements Specifications.

1  Introduction
Reusability of previous artifacts is considered a fundamental aspect in the
application development life cycle, since it can shorten the development
process, from the early requirements engineering to the detailed design and
implementation [4,5,20,26,31]. For what concerns reusability of software
artifacts, problems related to the identification, classification, retrieval,
adaptation, and composition of components have been widely studied, and
solutions based on techniques and paradigms of the software engineering field
have been proposed [6,18,23,24,25]. Our research focuses on reusability of
requirement specifications during the Requirements Engineering activity of the
development life cycle[10,11,16,17,22,30]. Experimentation and validation of
our approach are being performed in the framework of the Esprit project
n.6612 F3 (From Fuzzy to Formal) aiming at defining a methodology and a
software environment that integrates into a coherent whole a selection of
adequate techniques, to manage and improve the requirements engineering
process.
Two separate processes are required to enforce requirements reuse: design-for-
reuse and design-by-reuse. Design-by-reuse is performed when a new conceptual
schema is constructed not from scratch, but tailoring reusable components
retrieved from a reuse repository. Design-for-reuse is necessary to populate the
reuse repository with reusable components, properly defined to encapsulate
the domain knowledge, exploitable for subsequently developing new
applications not from scratch. The reuse-based development process requires a
reuse engineer, who is responsible for the population of the reuse repository,
and several application designers, which utilize the reuse repository (Fig.1).
 The reuse engineering team defines reusable conceptual components in the
form of generic components and associated guidelines, extracted from a
collection of existing application conceptual schemas, and stores them in a
reuse repository. Available components can then be retrieved and reused by
application designers to specify new schemas not from scratch, but
personalizing and tailoring retrieved components, according to the suggested
guidelines.
The paper is organized as follows. In Sect.2, our reuse environment is described,
based on the development lifecycle presented in Fig.1, while in Sect.3 the
related research work is discussed.

Fig. 1.  The reuse-based application development process

2  An environment for requirements reuse

Within the F3 project, we propose models, methods, and tools to support both the design-for-reuse and
the design-by-reuse, specifically oriented to the requirement specifications reuse problem [10,13].
In Sect.2.1 the reuse meta-model is described. In Sect.2.2 the reuse methodology is presented, and,
finally, in Sect.2.3, the architecture of the tools supporting the proposed methodology is illustrated.
2.1  Reuse meta-model
In order to present in a systematic way the reuse model underlying both the
design-for-reuse and the design-by-reuse processes, we introduce a reuse meta-
model, describing the key concepts characterizing our approach.
The reuse meta-model has been defined using the Entity-Relationship model
[3] to give an integrated an coherent description of all the needed inputs and
results of the reuse environment. The reuse meta-model is shown in Fig.2. A
reusable component is defined as a Generic Component, with an associated
Guideline-Component. Reusable components are defined by analyzing existing
conceptual schemas of the applications in a given domain. We consider a
conceptual schema as a collection of (application) components, expressed in a
suitable conceptual model, describing the entities of the real world, their
relationships, properties, and, possibly, the associated processes [3,15,32].
Schemas produced by application designers are selected, analyzed,clusterized,
and properly arranged inside the repository. Precisely, to each schema a set of
schema descriptors is associated [14]. In the repository, schemas are grouped
by similarity levels into clusters, on the basis of the shared schema descriptors.
For each schema cluster, affinity sets are defined, grouping the most similar
schema components, that are modified and engineered into reusable
components. For instance,in the Extended Entity-Relationship model, we
consider entities as reusable components,together with their attributes, their
relationships, which show how the component can be inserted in a schema,
and is-a relationships.
In general, we assume to work within a given application domain, e.g.office
domain, air traffic control domain, banking domain, education domain. For a
domain is essential to identify and define the terms frequently used in the
domain (synonyms, homonyms, and so on), to determine both schema and
component similarity. Thus, werefer to a Thesaurus as the base for all this
information.



Fig.2  The reuse meta-model
2.2  Reuse methodology
In F3 we are specificallyconcerned with the design-for-reuse process. To this
purpose, a reuse methodology for the construction of reusable components and
their associated guidelines has been defined. Starting from properly selected
application schemas, common and similar conceptual components are
identified and classified; from these components generic components and
associated guidelines are extracted and stored in the reuse repository.
The phases of the F3 reuse methodology are the following:
Ñ    selection of candidate schemas
Ñ    classification of candidate schemas
Ñ    selection and classification of candidate components
Ñ    design of reusable components
Ñ    assimilation of reusable components
Goals and characteristics of each phase are briefly described in the following.
During the first phase, the reuse engineer selects the schemas judged significant
for both their design quality and prospect reuse. Criteria andmetrics to
evaluate the reuse goodness of a schema in a given domain are under study.
The remaining methodological phases are based on the concept of
similarity[30,22]. It is widely accepted that, in order to be reusable, a
component should be apt to be used in more than one application, possibly
with adaptations and modifications according to the specific application
requirements. To minimize the required operations of adaptation and
tailoring, and to provide powerful components, similarities in different
application schemas should be identified, and commonalties abstracted into
generic components. To facilitate this process, we identify firstly similar
schemas, and secondly similar components within similar schemas. The
classification model adopted for schemas and components is based on
indexing criteria and clustering techniques, derived from the Information
Retrieval area [29].
Schemas are indexed by means of schema descriptors, selected among the
names associated to the schema components, for their capability of describing
the schema subject [7,14]. Using the selected schema descriptors, the schemas
are properly clusterized according to their level of similarity, giving origin to
several schema clusters inside the repository, using information retrieval
clustering techniques [28,29].
The schema clusters constitute the starting point for defining reusable
components. Selected a cluster, semantic affinity between schema components
is computed taking into accountthe structural and contextual properties of the
components (e.g.,attributes, generalization hierarchies, relationships). Schema
components presenting a semantic affinity greater than a predefined threshold
are grouped into affinity sets, i.e.,hierarchical structures whose leaves are the
examined components, and the intermediate nodes are numerical values
expressing the level of affinity for the corresponding components.
Affinity sets are used by the reuse engineer to extract generic components, in
that the properties and relationships common to all the affinity set members
are identified and factored out into the corresponding generic component. For
each generic component the corresponding guidelines are defined, including
reuse suggestions to personalize the generic componentin specific contexts.
Adaptations and modification suggestions  are given in the form of design
operations, applicable to the generic component (e.g.,refinement,
specialization, aggregation operations) [15,9].
Finally, newly created reusable components must be assimilated within the
reuse repository, to enrich the existing reusable components and to augment
their description capabilities. To this purpose, we are studying view integration
techniques to properly integrate the new components with the existing ones
[2].
2.3  Reuse tools
A couple of tools characterize our reuse environment, precisely the EXTRACT
tool, supporting the design-for-reuse process and the RECAST tool supporting
the design-by-reuse process, interacting with the reuse repository, and with
other tools in the F3 requirement engineering support environment ( Fig.3).



Fig.3  Global F3architecture

The RECAST tool [1,17], developed first within the ITHACA ESPRIT project, and
now under refinement to be integrated within the F3 reuse environment,
supports the design-by-reuse process. Such a tool provides a workspace where
components are graphically represented and interconnected according to
composition rules [12]. More precisely, it enforces the retrieval of reusable
components from the reuse repository via browsing and querying
functionalities, providing also guidelines to tailor and compose, at various
refinement levels, the retrieved components, according to given strategies and
application contexts.
The EXTRACT tool has been specifically designed and implemented to support
the reuse methodology described in Sect.2.2. In the following, its functionalities
are briefly described. Basically, EXTRACT is an interactive tool, such as the
reuse tools proposed in [30,22], assisting the reuse engineer in defining new
reusable components.
In order to assist the reuse engineer during selection of candidate schemas,
EXTRACT will provide a functionality of retrieval and selection ofexisting
schemas, according to suitable reuse metrics and selection criteria. Selection
functionalities will be built on top of the browsing and retrieval functionalities
provided by the reuse repository (see [13] for further details about the reuse
repository implementation).
To properly arrange selected candidate schemas within the repository,
EXTRACT provides a schema classification functionality, whereby the reuse
repository is populated in a systematic way. EXTRACT classifies reuse candidate
schemas according to the following steps:
Ñ    automatic selection of schema descriptors, using the procedure detailed
in [10].The reuse engineer can adjust in an interactive way the threshold
value for descriptor selection according tothe schema contents, and can
force the inclusion of specific/meaningful descriptors, in order to
improve the quality of the  schema indexing;
Ñ    computation of the schema similarity for all the indexed schemas;
Ñ    definition of the similarity clusters, using the single link clustering
technique.
Starting from the schema clusters, EXTRACT selects candidate components and
classifies them according to their semantic affinity. The following steps are
performed by EXTRACT:
Ñ    pairwise semantic affinity comparisons for conceptual components that
are descriptors of schemas in a given cluster;
Ñ    automatic definition of affinity sets, using the complete link clustering
technique [29] and the affinity coefficients. The reuse engineer can
examine the affinity sets, and interactively modify the affinity threshold,
to improve and/or refine their composition.
The reuse engineer can then invoke the definition of reusable components
functionality of EXTRACT, to extract the reusable component for defined
affinity sets. Precisely, EXTRACT performs the following operations:
Ñ    automatic definition of a Generic Component, by considering the
structural properties, and the contextual properties (relationships,
generalization hierarchies) common to all the affinity set components.
The reuse engineer can interactively modify the number of affinity set
components to be considered for the commonalities' extraction, in order
to refine the definition of the generic component;
Ñ    interactive definition ofreuse guidelines for a Generic Component, in
form of design operations to be applied to the generic component to
adapt and tailor it to specific contexts.


3  Related work
Several research efforts are currently in progress in the requirements reuse area.
They are mainly related to the design-by-reuse process, and most of the
currently available systems provide some form of support for the application
developer, in retrieving and tailoring selected reusable components, exploiting
either the analogy paradigm, or the artificial intelligence techniques. In
particular, in [16] a reuse analogy-based model is proposed, and the TRUE tool
based on that model is described, supporting the reuse of transaction
specifications. Starting from the target application requirements, a set of
reusable specifications are retrieved,exploiting different retrieval strategies,
based either on analogical reasoning, oron browsing of similar components.
Retrieved components can then be used through restructuring, editing, and
tailoring operations, to fit the new requirements. In [22] an analogy based
approach is proposed for reusing requirements specification, and reusable
specifications are given in form of abstract domain models, supporting reuse
across several applications. A prototype tool, called Ira, is described, enforcing
the design-by-reuse, by providing retrieval functionalities, and customization
guidance to tailor the retrieved candidate specifications to the target domain.
Abstract domain models proposed in [22] are similar to the clichÄ  proposed in
[27], where a tool to assist the acquisition of requirements is proposed, based
on artificial intelligence techniques to support the knowledge acquisition
process. Acquired requirements are matched against existing validated
clichÄ,describing the commonly occurring structures in one or more domains.
In [30] the concept of similarity is exploited to allow requirements reuse. Here
an interactive environment is described, where a set of tools helpapplication
designers in retrieving and reusing object-oriented requirements specifications
similar to the application at hand, properly selected among the stored
specifications, on the basis of their level of similarity. In [19] an approach is
proposed, to develop new information systems requirements making use of
generic structures properly instantiated to the current context, with more
emphasis for the engineering process rather than the definition process of
generic structures.
Our research addresses the design-for-reuse process, and we propose a
constructive approach for defining reusable components, while this aspect of
reuse is sometimes given as a de facto. We cover the problem of repository
population, (generally left open or dealt with using examples), by building
reusable generic specifications for both static (see [7,8,10]), and dynamic
aspects (see [11,12,13]) of the application requirements, presenting generic
features like those of the abstract domain models proposed in [22], and the
clichÄ illustrated in [27].


Acknowledgements
Part of this work has been supported by the ESPRIT III Projectn.6612 F3 (From
Fuzzy to Formal) and by the Italian National Research Council ╥Progetto
Finalizzato Informatica e Calcolo Parallelo╙, L.R.C. Infokit.

References
[1]    M.Ader, O. Nierstrasz, S. McMahon, G. Muller, A. K. Proefrock, "The
ITHACA Technology: a Landscape for Object-Oriented Application
Developement", Proc. ESPRIT'90 Conf. , Kluwer Academic Publisher,
November 1990
[2]    C. Batini, M. Lenzerini, S.B. Navathe, ╥A Comparative Analysis of
Methodologies for Database Schema Integration╙, ACM Computing
Surveys, Vol.18, December 1986,pp.323-364
[3]    C. Batini, S. Ceri, S.Navathe, Conceptual Database Design, Addison Wesley,
1991
[4]    D.Batory, S.O'Malley, ╥The Design and Implementation of Hierarchical
Software Systems with Reusable Components╙, ACMTOSEM, Vol.1,N.4,
October 1992, pp.355-398
[5]    T.J. Biggerstaff, A.J. Perlins(eds.), ╥Software Reusability - Concepts and
Models╙, vol.I, ACM Press, Addison-Wesley, 1990
[6]    G. Caldiera, V.R. Basili, "Identifying and qualifying reusable software
components", IEEE Computer, Vol. 24, N. 2, Feb. 1991
[7]    S.Castano, V. DeAntonellis, B. Zonta, ╥Classifying and reusing conceptual
schemas╙, in Proc. of ER'92, Int.Conf. on the Entity-Relationship Approach,
LNCS n.645, Springer Verlag, Karlsruhe, October 1992
[8]    S.Castano, V. DeAntonellis, ╥A Model for Reusable Requirements╙, F3
Report, F3.PdM.2-1-3-R1,November 1992
[9]    S.Castano, V. DeAntonellis, ╥Reuse of Conceptual Requirement
Specifications╙, in Proc. of RE ╒93,ACM/IEEE Int. Conf. on Requirements
Engineering, San Diego, CA, January 1993
[10]    S.Castano, V. DeAntonellis, ╥A Constructive Approach to Reuse of
Conceptual Components╙, in Proc. of 2nd ACM/IEEE Int. Workshop on
Software Reusability, Lucca, Italy, March1993
[11]    S. Castano, V. DeAntonellis, ╥Reusing Process Specifications╙, in Proc. IFIP
Working Conference on Information System Development Process,IFIP WG
8.1, Como, Italy, September 1993, North-Holland, pp.267-283
[12]    S. Castano, V. De Antonellis, C.Francalanci, M.G. Fugini, B. Pernici,
R.Bellinzona, L. Vandoni, ╥Methodology for reuse╙, F3 Report, F3.PdM.2-1-
3-R2, Politecnico di Milano, April 1993
[13]    S. Castano, V. DeAntonellis, P.Sanpietro, ╥Reuse of Object-Oriented
Requirements Specifications╙, to appear in Proc. ER '93, 12th Int. Conf.on
The Entity Relationship Approach, Dallas Arlinghton, TX, USA, December
1993
[14]    V. DeAntonellis, B. Zonta,╥A disciplined Approach to Office Analysis╙,  IEEE
TSE,Vol. 16, No. 8, 1990, pp. 822-828
[15]    V. DeAntonellis, S. Castano, B. Pernici, A. Piovesana, ╥The ITHACA Object
Oriented Methodology: Application Developer Manual╙, ITHACA Report,
ITHACA.POLIMI-UDUNIV, 1992
[16]    A.Finkelstein, ╥Reuse of Formatted Requirements Specifications╙, Software
Engineering Journal, September 1988,pp.186-197
[17]    M.G. Fugini, O. Nierstrasz, B. Pernici, ╥Application Development through
Reuse: the Ithaca Tools Environment╙,  SIGOIS Bulletin, vol. 13, n.
2,August 1992
[18]    M.G. Fugini, S. Faustle, ╥Querying a Software Information Base for
Component Reuse╙, to apper in Proc. of 2nd ACM/IEEE Int. Workshop on
Software Reusability, Lucca, Italy, March1993
[19]    G.Grosz, ╥Buiding Information System Requirements Using Generic
Structures╙, Nature Report Series N.92-06, 1992
[20]    C.W.Krueger, ╥Software Reuse╙, ACM Computing Surveys, Vol.24, N.2, June
1992, pp.131-183
[21]    Y.S. Maarek, D.M.Berry, G.E. Kaiser, ╥An Information Retrieval Approach
For Automatically Constructing Software Libraries╙, IEEE TSE, Vol.17,No.8,
August 1991, pp.800-813
[22]    N.A. Maiden, A.G. Sutcliffe,╥Exploiting Reusable Specifications Through
Analogy╙,Communications of the ACM, Vol.35, N.4, April 1992, pp.55-64
[23]    J.W. Hooper, R. O. Chester, Software Reuse: Guidelines andMethods,
Plenum Press, Division of Plenum Publishing Corporation, NewYork, 1991
[24]    E. Ostertag, J. Hendler, R. Prieto-Diaz, C. Braun, ╥Computing Similarity in
a Reuse Library System: An AI-Based Approach╙, ACM TOSEM, Vol.1, No.3,
July 1992, pp.205-228
[25]    R. Prieto-Diaz, ╥Implementing Faceted Classification for Software  Reuse╙,
Comm. of the ACM,  vol. 34,n. 5, May 1991
[26]    Proceedings of REBOOT Workshop on Reuse, Esprit Project 5327,Grenoble,
September 1991
[27]    H.B. Reubenstein, R.C.Waters, ╥The Requirements Apprentice: Automated
Assistance for Requirements Acquisition╙, IEEE TSE, Vol.17, N.3, March 1991
[28]    G. Salton, Automatic Textt Processing - The Transformation, Analysis and
Retrieval of Information by Computer ,  Addison-Wesley, 1989
[29    G. Salton, Ch. Buckley, ╥Term Weighting Approachesin Automatic Text
Retrieval╙, Information Processing andManagement,  vol. 24, Nr. 5,  1989,
pp.513-523
[30    G.Spanoudakis, P.Constantopoulos, ╥Similarity for Analogical Software
Reuse: A Conceptual Modelling Approach╙, inProc. of CAiSE '93, Int. Conf.
on Advanced Information Systems Engineering, Paris, June 1993
[31]    W. Tracz ed., Software Reuse: Emerging Technology, IEEE Computer Society
Press, Washington D.C., 1988
[32]    R. Wirfs-Brock, B. Wilkerson, L. Wiener, Designing Object-Oriented Software,
Englewood Cliffs, NJ,  Prentice Hall, 1990

4  Biography
Valeria De Antonellis is a professor of computer science at the Politecnico di
Milano, Engineering Faculty. Her major areas of research include conceptual
models, methodologies and tools for databases and information systems
design. She is coordinator of the AICA WG on Databases. She is co-author of
Relational Database Theory (Benjamin Cummings) and co-editor of Computer-
Aided Database Design (North-Holland). She is currently responsible of the
research team from Politecnico di Milano in the ESPRITProject n. 6612 - F3
(From Fuzzy to Formal).
Silvana Castano is PhD student at the Politecnico di Milano,Engineering
Faculty. Her major areas of research are related to models and methods for
database and information system design. She is currently member of the
research team from Politecnico di Milano in the ESPRIT Project n.6612 - F3
(From Fuzzy to Formal).