Hafedh Mili

Reusing software: issues and research directions

Software productivity has been steadily increasing over the past 30 years, but not enough to close the gap between the demands placed on the software industry and what the state of the practice can deliver; nothing short of an order of magnitude increase in productivity will extricate the software industry from its perennial crisis. Several decades of intensive research in software engineering and artificial intelligence left few alternatives but software reuse as the (only) realistic approach to bring about the gains of productivity and quality that the software industry needs. In this paper, we discuss the implications of reuse on the production, with an emphasis on the technical challenges. Software reuse involves building software that is reusable by design and building with reusable software. Software reuse includes reusing both the products of previous software projects and the processes deployed to produce them, leading to a wide spectrum of reuse approaches, from the building blocks (reusing products) approach, on one hand, to the generative or reusable processor (reusing processes), on the other. We discuss the implication of such approaches on the organization, control, and method of software development and discuss proposed models for their economic analysis. Software reuse benefits from methodologies and tools to: (1) build more readily reusable software and (2) locate, evaluate, and tailor reusable software, the last being critical for the building blocks approach. Both sets of issues are discussed in this paper, with a focus on application generators and OO development for the first and a thorough discussion of retrieval techniques for software components, component composition (or bottom-up design), and transformational systems for the second. We conclude by highlighting areas that, in our opinion, are worthy of further investigation. >

Design of class hierarchies based on concept (Galois) lattices

Building and maintaining the class hierarchy has been recognized as an important but one of the most difficult activities of object-oriented design. Concept (or Galois) lattices and related structures are presented as a framework for dealing with the design and maintenance of class hierarchies. Because the design of class hierarchies is inherently an iterative and incremental process, we designed incremental algorithms that update existing Galois lattices as the result of adding, removing, or modifying class specifications. A prototype tool incorporating this and other algorithms has been developed as part of the IGLOO project, which is a large object-oriented software engineering joint research project involving academic and industrial partners. The tool can generate either the concept lattice or several variant structures incrementally by incorporating new classes one by one. The resulting hierarchies can be interactively explored and refined using a graphical browser. In addition, several metrics are computed to help evaluating the quality of the hierarchies. Experiments are presented to better assess the applicability of the approach.

Business process modeling languages: Sorting through the alphabet soup

Requirements capture is arguably the most important step in software engineering, and yet the most difficult and the least formalized one [Phalp and Shepperd 2000]. Enterprises build information systems to support their business processes. Software engineering research has typically focused on the development process, starting with user requirements—if that—with business modeling often confused with software system modeling [Isoda 2001]. Researchers and practitioners in management information systems have long recognized that understanding the business processes that an information system must support is key to eliciting the needs of its users (see e.g., Eriksson and Penker 2000]), but lacked the tools to model such business processes or to relate such models to software requirements. Researchers and practitioners in business administration have long been interested in modeling the processes of organizations for the purposes of understanding, analyzing, and improving such processes [Hammer and Champy 1993], but their models were often too coarse to be of use to software engineers. The advent of ecommerce and workflow management systems, among other things, has led to a convergence of interests and tools, within the broad IT community, for modeling and enabling business processes. In this article we present an overview of business process modeling languages. We first propose a categorization of the various languages and then describe representative languages from each family.

Toward an engineering discipline of software reuse

This article stems from a panel session at the 1997 Symposium on Software Reusability, and discusses open research issues, classified by goal and by approach. Software development cannot possibly become an engineering discipline so long as it has not perfected a technology for developing products from reusable assets in a routine manner, on an industrial scale. Software reuse cannot, in turn, achieve this status unless we make the following provisions: a sound scientific foundation that encompasses relevant design principles, widely acceptable engineering standards that compile these principles into working practical solutions, and coherent managerial standards that enable the deployment of these solutions under acceptable conditions of product quality and process maturity. Although successful software reuse experiments are increasingly common, success is not the norm, software reuse is not a matter of routine practice, the promises of software reuse remain for the most part unfulfilled, and a number of issues remain worthy of further research.

Another nail to the coffin of faceted controlled-vocabulary component classification and retrieval

Our research centers around exploring methodologies for developing reusable software, and developing methods and toofs for building with reusable software. In this paper, we focus on reusable software component retrieval methods that were developed and teated in the context of ClassServer, an experimental library tool developed at the University of Qu6bec at Montr6al to explore fssues in software reuse [15]. The methods dfscusaed in tbfa paper fall into two categori~ 1) string search-based retrieval metbod

Merging thesauri: principles and evaluation

and 2) keyword-based retrieval methods. Both kinds of methods have been implemented and tested by researchers, both in the context of software repositories (see e.g. [6,9]) and in the context of more traditional document tibrarles (see e.g. [2,25]). Experiments have shown that keyword-based methods, which require some manual, laborintensive pre-proceashrg, performed only marginally better than the entfrely mechanical strhtgsearch methods (see e.g.[6, 2S]), raising the issue of cost-effectivene= of keyword-based methods as compared to string search baaed methods. In this paper, we describe an implementation and experiments which attempt to brfng the two khtds of methods to a level-playing field by: 1) automating as much of the pre-processing involved hr controlled vocabulary-based methods as possible to address the crds issue, and 2) using a realistic experimental setting in which queries consist of problem statemenlx rather than component specifications, in whjch query results are aggregated over several trials, and in which recaU measures take into account overlapping components. Our experiments showed that string search based methods performed better than semi-controlled vocabulary-based method

A framework for framework documentation

which goes further in the direction of more recent component retrfeval experiments which challenged the superiority of controlled vocabulary based clarification and retrieval of components (see e.g. [61).

A model-driven framework for representing and applying design patterns

An investigation is reported of ways to take advantage of the semantics in thesauri to improve: (1) indexing by providing descriptions of documents as sets of terms from the thesaurus; and (2) retrieval by assessing the relevance of documents to a query. Thesauri need to be updated to account for the evolution of the field they cover. Accordingly, various augmentation algorithms and methods to assess the usefulness of these augmentations are being studied. The augmentations consist of merging two existing thesauri. By keeping a consistent level of complexity among the structure manipulated by the merging algorithm, the reasoning method, and the evaluation procedure, an improvement of the performance of the merged thesaurus on both document indexing and retrieval is demonstrated. >

Practitioner and SoftClass: a comparative study of two software reuse research projects

Frameworks are quite di cult to understand when one rst uses them: the design is very abstract, to factor out commonality; the design is incomplete, requiring additional subclasses to create an application; the design provides exibility for several hotspots, not all of which are needed in the application at hand; and the collaborations and the resulting dependencies between classes can be indirect and obscure. Many approaches to documenting frameworks have been tried, though with di erent aims and audiences in mind. In this paper, we present a task-oriented framework for framework documentation. Our framework is based on rst identifying a set of framework (re)use cases, which we then decompose into a set of elementary engineering tasks. Each such task requires a set of documentation primitives, enabling us to specify a minimal set of documentation primitives for each framework usage scenario. We study some major framework documentation approaches in light of this framework, identifying possible de ciences and highlighting directions for further research.

Detecting Patterns of Poor Design Solutions Using Constraint Propagation

Design patterns encode proven solutions to recurring design problems. To use a design pattern properly, we need to 1) understand the design problem the pattern resolves, 2) recognize an instance of this problem in the model at hand, and 3) to transform the model to produce the proposed solution. We argue that an explicit representation of the design problem solved by a pattern is key to supporting each one of these tasks. We propose to represent a design pattern using a triple (MP, MS, T) where MP is a model of the design problem solved by the pattern, MS is a model of the solution proposed by it, and T is a rule-based representation of the transformations embodied in the application of the pattern. In this paper, we describe the principles underlying our approach and the current implementation using the Eclipse Modeling FrameworkTM and JRulesTM.