Configurable Software Architecture in Support of Configuration Management and Software Deployment Andr´e van der Hoek Department of Computer Science University of Colorado Boulder, CO 80309 USA
[email protected] In this research abstract we introduce the M´enage project. M´enage is based on the vision that the notion of software architecture, extended with the concept of versioning, can be used as an organizing abstraction for some of the activities in the software life cycle. In particular, we are investigating how two of those activities, namely configuration management and software deployment, can benefit from the availability of an explicit architectural representation that is enhanced with versioning capabilities. 1 Introduction The M´enage project is based on a rather different kind of research philosophy. Instead of focusing on a specific problem and its solution, it is opportunistic in nature. That is, the focus of M´enage is not some kind of problem, but instead an investigation into whether it could be beneficial to apply certain tools and techniques outside of the domain in which they have traditionally been used. In the case of M´enage, we are looking at the emergence of the discipline of software architecture as an opportunity to advance the disciplines of configuration management and software deployment. It is our belief that architectural modeling techniques and their associated tools can be used to improve the way certain configuration management and software deployment tasks are carried out. As described in detail in previous work, this belief is grounded in the following two observations: architecture adds structure to process, and architecture description languages model other information about a system besides its structure [7]. But, software architecture by itself is not sufficient. First of all, architectures evolve. Second, a single architecture can exist in multiple variants. To manage this architectural evolution and variability, we believe that software architecture should be extended with versioning capabilities. It should be noted that this does not
just involve the addition of version numbers to architectural descriptions. Rather, we are concerned with the identification of proper versioning policies for software architecture, the creation of advanced selection mechanisms to choose a particular software architecture out of the set of available versions, the development of an understanding of architectural differences, and the creation of architectural merging algorithms. The resulting abstraction, namely configurable software architecture, is at the heart of our thesis. The use of configurable software architecture is beneficial for the activities of configuration management and software deployment. The goal of the M´enage project is to validate this thesis. To do so, we need to create the following four entities: a representation for configurable software architecture, an environment that supports the creation of architectures that evolve and are variable, a configuration management system that is based on configurable software architecture, and a software deployment system that is based on configurable software architecture. 2 Initial Results Our initial work has been concerned with the definition of a representation for configurable software architecture and the creation of an environment that supports the specification of configurable software architectures. Without these, the remainder of our work would, of course, be impossible to carry out. Our representation for configurable software architecture is based on Acme [2] and Darwin [3], and has been enhanced with the versioning techniques that were introduced by PCL [6]. An important aspect of the representation is that it is language independent; our tools work in terms of this language-independent specification, but rely on a translation to an actual ADL to provide auxiliary functionality. Based on our representation, we have implemented a prototype design environment for configurable software architecture. This environment allows the design and evolution of architectures that are variable. The envi-
ronment is similar to other design environments, but the unique aspect of M´enage is that all entities are versioned, and that components are constructed in terms of specific versions of these entities.
can be measured. In particular, we intend to model the large-scale industrial system twice; once to demonstrate the old situation (by modeling the system separately in an ADL, a configuration management system, and a software deployment system) and once to illustrate the new situation (by modeling the system only in configurable software architecture). We believe we will be able to show a reduction in total modeling effort.
Evolution is handled through a traditional checkin/check-out mechanism that is based on a version tree. Branches are allowed in the version tree, but only as a mechanism to handle parallel work; in contrast to traditional configuration management techniques, branches should not represent logical variants. Instead, we have introduced the concept of variant components. Variant components logically relate variants while distinguishing them based on a certain property. A higher-level component has to specify the value of this property to, in essence, instantiate a particular variant. The advantage of variant components over branching is that variant components are more powerful: they can relate independently specified components as variants, whereas branches can only relate variants of a single component.
4 Related Work Although no other effort is currently evaluating the application of software architecture to configuration management and software deployment, software architecture has been used to support other activities in the software life cycle. In particular, architecture-based testing has been proposed [5] and an architecture-based editor has been implemented [1]. Additionally, software architecture has been used as a mechanism to support dynamic reconfiguration [4]. Our work differs from these efforts in two critical ways. First, M´enage is based on configurable software architecture as opposed to just software architecture. This addition of versioning allows the development of new capabilities (such as minimal component update) that would otherwise not be possible. The second difference is that, whereas other efforts have focused on supporting just one activity, M´enage focuses on two activities in order to demonstrate that the use of configurable software architecture also benefits the communication between these activities.
3 Evaluation To evaluate the concept of configurable software architecture and its use to support the activities of configuration management and software deployment, we need to look at the three main benefits that we expect to arise. We intend to demonstrate these benefits through the use of two example systems that we will manage and evolve with the prototype tools we have developed. The first example system is a small-scale system that is currently in use for numerical analysis purposes. This system will be used to demonstrate the feasibility and functionality of our approach. The second system, a large-scale industrial system (not yet obtained), will be used to demonstrate that our approach and tools scale.
REFERENCES [1] P. Bucci, T. Long, and B. Weide. Teaching Software Architecture Principles in CS1/CS2. In Proceedings of the Third International Software Architecture Workshop, pages 9–12, Nov. 1998. [2] D. Garlan, R. Monroe, and D. Wile. ACME: An Architecture Description Interchange Language. In Proceedings of CASCON ’97. IBM Center for Advanced Studies, Nov. 1997. [3] J. Magee, N. Dulay, S. Eisenbach, and J. Kramer. Specifying Distributed Software Architectures. In Proceedings of the Fifth European Software Engineering Conference, number 989 in Lecture Notes in Computer Science, pages 137–153, New York, New York, Sept. 1995. Springer-Verlag. [4] N. Medvidovic. ADLs and Dynamic Architecture Changes. In L. Vidal, A. Finkelstein, G. Spanoudakis, and A. Wolf, editors, Joint Proceedings of the SIGSOFT ’96 Workshops, pages 24–27, New York, New York, 1996. ACM Press. [5] D. Richardson and A. Wolf. Software Testing at the Architectural Level. In L. Vidal, A. Finkelstein, G. Spanoudakis, and A. Wolf, editors, Joint Proceedings of the SIGSOFT ’96 Workshops, pages 68–71, New York, New York, 1996. ACM Press. [6] E. Tryggeseth, B. Gulla, and R. Conradi. Modelling Systems with Variability using the PROTEUS Configuration Language. In Software Configuration Management: ICSE SCM-4 and SCM-5 Workshops Selected Papers, number 1005 in Lecture Notes in Computer Science, pages 216–240, New York, New York, 1995. Springer-Verlag. [7] A. van der Hoek, D. Heimbigner, and A. Wolf. Versioned Software Architecture. In Proceedings of the Third International Software Architecture Workshop, pages 73–76, Nov. 1998.
The first benefit, a rise in abstraction level, is demonstrated by the new capabilities that are incorporated in the prototype configuration management and software deployment systems that we will develop. These new capabilities share the fact that they operate at the component level, as opposed to the source code or executable level. We will merely use both example systems to demonstrate that the new capabilities actually work. The second benefit, a reduced context switch between the configuration management and software deployment activity, will be demonstrated by yet another new capability: when a new release of a system is created, the deployed versions of the system will be automatically updated. Normally, this capability would require a large amount of ad hoc programming. But, because of the use of configurable software architecture as an organizing abstraction in both our prototype systems, we believe we will be able to demonstrate this capability without the need for such programming. The third benefit, a reduction in total modeling effort, 2
