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
Presented at the 8th Annual Workshop on Software Reuse (WISR8)
A Postscript
version of this document is available.
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.
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 [GI95, Gir95]. 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.
The paper is organized as follows. Section 2 describes the requirements for software abstraction effectiveness and suggests the development of general-purpose software architectures to meet these requirements. Section 3 introduces some research directions which will enable or contribute with appropriate methods for building effective software architectural abstractions.
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.
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.
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 [GI95, Gir95] 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 [Ran97], 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.
On the other hand, experience and training on Domain Engineering techniques [ADP91] 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.
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.
Site Hosting: Bronco