Selecting Software Components with Multiple Interfaces Luis Iribarne University of Almer´ ıa Escuela Polit´ ecnica. 04120 Almer´ ıa, Spain liribarne@ual.es Jos´ e M. Troya and Antonio Vallecillo University of M´ alaga ETSI Inform´ atica. 29071 M´ alaga, Spain {troya,av}@lcc.uma.es Abstract Component-based software development is gaining recognition as the key technology for the construction of high-quality, evolvable, large software systems in timely and affordable manners. Component search and service matching have become two of the key issues involved in this process. However, current proposals addressing these is- sues are based on the simplistic assumptions that compo- nents present only one interface with the services they of- fer. This work presents an extension of those approaches in which components may offer and require several interfaces, extending the traditional component “substitutability” op- erator. In addition, an algorithm for selecting COTS com- ponents with multiple interfaces from a repository in order to implement a given software architecture is presented. 1. Introduction Component-Based Software Development (CBSD) is generating tremendous interest due to the need of plug-and- play reusable software for developing applications, which has led to the concept of ‘commercial off-the-shelf ’ (COTS) components. Although currently more a goal to pursue a than a reality, this approach moves organizations from ap- plication development to application assembly. In CBSD, constructing an application involves the use of prefabricated pieces, perhaps developed at different times, by different people, and possibly with different uses in mind. The ulti- mate goal is to be able to reduce development times, costs, and efforts, while improving the fle xibility, reliability, and reusability of the final application due to the (re)use of soft- ware components already tested and validated. In CBSD, the system designer has to take into account the specification of pre-developed COTS components avail- able in software repositories, that must be even considered when building the initial requirements of the system, in- corporating them into all phases of the development pro- cess [17, 21]. In this approach, an abstract software architecture of the system is defined first, that describes the specification of abstract components and their relationships. These abstract components are then matched against the list of concrete COTS components available in a repository. This process produces a list of the candidate components from the repos- itory that could form part of the application: both because they provide some of the services required by the appli- cation, and because they fulfil some of the user’s (non- functional) requirements such as price, security, etc. With this list, the system architecture is re-examined in order to accommodate as much candidates from the list a possible. Additionally, wrappers may be used for adapting the COTS components selected (for hiding extra services non required, or for adapting their interfaces for compatibility or interoperability), and some glue language can be also used for composing and coordinating component interactions. Traditionally, the search and matching processes of com- ponents have been defined on a one-to-one basis [9, 29, 30]. However, this is not the common case in most real appli- cations: COTS components are coarse-grained components that integrate several services and offer many interfaces. For instance, an Internet navigator or a Word processor, apart from their core services, they also offer others, such as web page composition, spell checking, and so on. This paper presents a proposal to deal with these issues. In particular, we study some of the problems that appear in this new setting—such as service gaps and overlaps— extending the traditional compatibility and substitutability operators to deal with components that support multiple in- terfaces. In addition, we also take into account the services that components require from other components, not only the services they support, according to the currently widely- accepted component-oriented programming paradigm [24]. This paper is structured into fi ve sections. After this in- troduction, Section 2 presents an overview of the COTS based software applications. Next, Section 3 presents our proposal and an example that illustrates it. After that, Sec- tion 4 discusses some related work, and finally Section 5 describes some conclusions, and future research activities. Proceedings of the 28 th Euromicro Conference (EUROMICRO’02) 1089-6503/02 $17.00 © 2002 IEEE