Rosario Girardi
Engineering College (UCUDAL and UR)
Av. 8 de octubre 2738
11600 Montevideo - Uruguay
Tel: + (598 2) 472-717
Fax: + (598 2) 808-124
Email:
girardi@fing.edu.uy
WWW:
http://www.fing.edu.uy/~girardi/home.html
Bertrand Ibrahim
University of Geneva
Department of Computer Science
24, rue General Dufour
1211 Geneva 4 - Switzerland
Tel: +41 (22) 705-7508
Fax: +41 (22) 705-7780
Email:
bertrand.ibrahim@cui.unige.ch
WWW:
http://cuiwww.unige.ch/eao/www/Bertrand.html
Gains of productivity through software reuse require important efforts for the construction of general-purpose high-level abstractions for reusable software artifacts through systematic approaches to Domain Engineering techniques. This paper sugggests general-purpose software architectures as appropriate abstractions to achieve this goal.
Keywords: Software Reuse, Development for Reuse, Software Abstraction, Software Architecture, Software Engineering
Workshop Goals: Exchanging ideas in similar areas.
Working Groups: Reuse of the Earliest Life-Cycle Artifacts.
Rosario Girardi has been working in software reuse since 1989. First, she worked with object-oriented development methodologies and their support to reuse [1, 2]. Later, she focused on software library issues using concepts from the information retrieval and computational linguistics fields [3, 4]. Currently, her main interest in the software reuse area is on software architectures for the creation of reusable software [5].
Bertrand Ibrahim has been involved with software reuse since 1987. He first worked on software reuse based on automatic code generation, within the context of a CASE environment for the development of computer-aided learning software. Later on, he focused on the automatic detection of reuse opportunities based on natural language description of software components.
Software reuse has been considered as a means to overcome the software crisis. However, the expectations of higher productivity in the development and maintenance of software and of better quality of the created software artifacts through software reuse have not been frequently met. This may be so because the effort needed to create reusable software artifacts, locate them, adapt them and integrate them in a specific application has very often been felt to be greater than the effort needed to create the application from scratch.
A few successful reuse experiences have been reported. Success has depended mainly on both knowledge and development experience of particular application domains. Good results have been obtained on well-known domains and with domains where there is a mature development experience.
Two main technical problems currently limit successful reuse. One of them concerns software library features with the need for mechanisms to retrieve software artifacts effectively according to user requirements. Advances in information retrieval and natural language processing techniques have provided some directions to approach this problem [3, 4]. Another problem concerns development for reuse activities with the need for mechanisms to create effective software abstractions providing a considerable improvement of productivity through their reuse.
The reuse community has shown the relevance of the productivity benefits of reusing early life-cycle artifacts, like design specifications, rather than the simple low-level reuse of source code. Therefore, there is a need for mechanisms to identify and create high-level software abstractions.
This paper aims at showing the relevance of the effort that should be invested on the development of both general-purpose high-level abstractions and mechanisms to easily map these abstractions onto executable implementations, to improve the effectiveness of reuse techniques. Current advances and research directions for the identification and development of software architectural abstractions are also discussed.
All approaches to software reuse use some form of abstraction for software artifacts. A software abstraction is a high-level, succinct, natural and useful specification that corresponds to a realization in a more detailed level of representation [6].
An abstraction consists of a hidden part (the details of the abstraction realization that are not visible in the abstraction specification), a variable part (the variant characteristics in the abstraction realization), and a fixed part (the invariant characteristics in the abstraction specification).
Abstractions play a central role in reuse activities. Concise abstractions are needed to efficiently locate, understand, compare, and select the appropriate software artifacts from a collection. Specialization of a generalized software artifact corresponds to choosing an abstraction realization from the variable part of an abstraction specification. Finally, to compose a set of software artifacts, users must understand the artifact interface which must be clearly described in the abstraction specification.
Considering software productivity, the effectiveness of a reuse technique can be measured in terms of the cognitive distance: the intellectual effort that is required to take a software system from one stage of development to another. Moreover, a reuse technique should reduce the cognitive distance between the conception of a system at the highest level and its final executable implementation [6]. This can be accomplished by both moving the abstraction specifications closer to the abstractions used to reason about the application domain, and partially or fully automating the mapping from abstraction specifications to executable abstraction realizations.
On the other hand software abstractions should ideally be applicable to a broad range of application domains to quickly pay off the cost of their development.
Important improvements of software productivity have been obtained with the generative reuse approach using application generators [7]. This approach allows to map high-level abstractions from the application domain directly into executable source code. However, the construction of an application generator with appropriate functionality and performance for a broad range of applications has been proven difficult.
Software architecture is both a discipline of design, and also a representation of high-level design. Reusable software architectures allow the reuse of designs and code as a whole (e.g. user interface architectures).
Like application generators, reuse techniques based on software architectures reduce cognitive distance. They can also be created directly from application domain abstractions and they can be as well automatically mapped into executable implementations. However, application generators have implicit architectures, whereas reusable software architectures can be used as either application generators to create end-user applications or as building blocks which are selected, specialized and integrated to construct more complex architectures, satisfying user requirements and possibly sharing functionality across domains.
Therefore, effort in the creation of general-purpose libraries of software architectures appears as a promising direction for successful reuse. This can take advantage of the considerable experience and knowledge of methods, tools and techniques already existent to structure complex software systems.
Library systems [3, 4] should be available to help software developers find software architectures with the smallest cognitive distance between the architecture and the application requirements. Mechanisms for composing software architectures should also be developed.
On the other hand, cognitive distance should also be minimized during the creation of reusable software architectural abstractions. To achieve this, application developers should maximize the hidden part of the generic software architectures while defining fixed and variable parts that are expressive enough. Mechanisms for the automated mapping of architectural abstractions to executable implementations should also be available. Alternative realizations should be identified and specified in the variable part of the architecture specification to satisfy domain coverage requirements.
An approach has been recently proposed according to these requirements [8], named overlay designs. The idea is based on the metaphor of overhead slides that may be stacked to create a composite image. Alternative realizations or specific designs are considered for each variant part of the architecture. These alternative realizations are compared for common and different parts. The common part is then separated as the fixed part of the design abstraction and the different parts are kept in the variant part of the abstraction. A complete design for a variant product should be then a simple combination of several overlays.
Advances on the study field of software architectures will provide the basic framework for the development of effective software architectural abstractions. Software architectural research should address issues like the definition of architectural description languages to describe architectural designs, formal models of software architectures, methods for software architectural development, architecture recovery and reengineering for the extraction of architectural design from existing systems, formalisation of architectural design expertise, tools and environments for architectural design and retrospective analysis of successful architectural development [9].
On the other hand, experience and training on Domain Engineering techniques [10] should be necessary to support the Development for Reuse activities and the construction of software architectures common to families of applications from existing systems. Domain Engineering requires both development experience in the domain and knowledge of application domains. Experience can be obtained by constructing several of the same kind of systems. However, this ad-hoc approach is very human dependent. Therefore, a systematic approach for Domain Engineering should be formulated, for instance, through reverse engineering techniques allowing to partially or fully automate the acquisition of development experience. Advances on knowledge acquisition and representation techniques will also promote a systematic approach for the construction of domain languages.
Rosario Girardi has graduated with a Ph. D. in Computer Science from the University of Geneva (1996). She is a professor at the Computer Science Institutes of the Catholic and State Universites, Montevideo, Uruguay. Her research interests and specialization areas are Software Engineering, Software Reuse, Object-Oriented Development, Information Retrieval and Computational Linguistic. She has 24 publications in journals (3), book articles (1), conferences (16) and research reports (4). She is a member of the Program Committee of the next International Symposium on Software Reusability and the Internacional Conference of Information Analysis and Synthesis.
Bertrand Ibrahim graduated from the University of Geneva in 1982 with a Ph.D. in Computer Science. He then turned to computer-based learning and was active in a number of fields: networks, multilingualism, software engineering and visual programming. He has been an invited researcher at the University of California, Irvine, many times between 1985 and 1991. He is a tenured assistant professor at the University of Geneva since 1986 as well as student counsellor for the CS department since 1991. He leads a team of researchers funded by the Swiss National Science Foundation and his current research activities focus mostly on semi-formal visual languages, on software reuse based on natural language description of software artifacts, and on pedagogical uses of the WWW.