Automatic composition of software systems from components with anonymous dependencies Ioana Sora, Frank Matthijs DistriNet labs, Department of Computer Science, K.U.Leuven, Belgium E-mail: Ioana.Sora@cs.kuleuven.ac.be Abstract In this paper, we discuss a way of composing a system from components where the dependencies between the components are not explicitly known. We make observations based on our experience with defining and implementing a composition mechanism for layered architectures. We propose a manner of specifying component descriptions to express anonymous dependencies between the components, an application-domain independent formalism for describing the client-specific configuration requests in terms of desired properties, and a composition algorithm that works well in these conditions. Secondly, we argue that the composition method should be independent from the application domain, only architecture-style dependent, which allows a larger reuse of the composition method. Configuration knowledge that is specific to a certain application domain may be incorporated in domain-specific front-end tools that accept client requirements expressed at a higher abstraction and translate them in the terms of a domain-unaware description language. We illustrate by giving an example of automatic composition of protocol stacks within DiPS [Mat99], our Distrinet Protocol Stack framework for building network subsystems. The integration of an automatic composition module into DiPS has validated our approach as a simple but powerful tool for customizing software to support client-specific requirements. 1 Motivation The goal of software composition is to find a good combination of components that leads to a software system that responds to client-specific requirements. Earlier research in the domain of composition has addressed the issue within the domain of software architectures, ADL’s [SDZ96] and composition languages [SN99]. In these cases, deciding a good component combination is done statically and relies on the application programmer. An important research issue is to automate this configuration process. Another important challenge in current computer systems is that they must be able to configure themselves dynamically, adapting to the environment in which they are executing. In the case of dynamic configuration, the issue of automatic vs. manual configuration is even more important. There is previous and ongoing research in the domain of dynamic and automatic configuration of component-based systems ([Kon00], [BCRP98] [HF98], [AW99], [TJJ00]). An essential step towards the possibility of implementing services that support automatic configuration is a good explicit representation of dependencies. In [KC00], a model for representing dependencies among components and mechanisms for dealing with these dependencies is proposed. Prerequisite specifications (including the nature and capacity of needed hardware as well as required software services) reify static dependencies of components towards their environment, while component configurators