Home > Software Development > Component-Based Software Engineering
Software Development
Component-Based Software Engineering »
Software Development Environments
Additional Information
All CBSE Publications

Component-Based Software Engineering

Component-based software enginering and software architectire is an emerging research area. It encompasses the traditional area of software design with an emphasis on the design of distributed systems. Based on the past failures of complex design techniques to gain wide spread acceptance, CBSE and software architecture languages must demonstrate that they provide significant value. A primary benefit will be the early detection of software faults. This is particularly important for distributed systems, since even simple distributed systems can be difficult to understand. LASER is exploring ways in which architectural description languages need to be designed to increase their usability, acceptability, and consequently analyzability.

Architecture-based Verification

Architecture-based verification is particularly important for distributed systems since it is often difficult to determine the appropriate interactions among the components. An approach is needed in which it is easy to experiment with different interaction models among the components in order to get early feedback about the impact on the overall behavior of the resulting systems. One of the problems that currently arise with this approach, however, is that the semantics of the components are inextricably intertwined with the semantics of the interaction model. For example, a simple change from an asynchronous send to a synchronous send requires that the component now be able to block and process an acknowledgement. Of course, more complex interactions models that support features, such as priorities and bounds, require more extensive component modifications. We have been developing a building block approach to architectural design that separates a component’s behavior from its interaction models as well as from the connectors. This leads to an architectural design where it is indeed possible to experiment with alternative interaction models without having to modify the components. We combine this approach with finite state verification so that developers can make architectural modifications and quickly receive feedback about the impact of these changes on important system properties.

Recent Publications

Plug-and-Play Architectural Design and Verification
Shangzhu Wang, George S. Avrunin, Lori A. Clarke, Architecting Dependable Systems V, Rogerio de Lemos, Felicita Di Giandomenico, Cristina Gacek, Henry Muccini, Marlon Vieira, eds., Springer-Verlag Lecture Notes in Computer Science, State of the Art Survey, vol. 5135, (2008), pp. 273-297. (UM-CS-2008-46)

This is an updated version of TR UM-CS-2008-01, dated January 2008.

[ Springer ] [ PDF ]

Verification Support for Plug-and-Play Architectural Design
Shangzhu Wang, George S. Avrunin, Lori A. Clarke, ACM SIGSOFT 2006 Workshop on Role of Software Architecture for Testing and Analysis (ROSATEA 2006), Portland, ME, pp. 49-50, July 2006. (UM-CS-2006-32)

[ ACM ] [ PDF ] [ Poster ]

Architectural Building Blocks for Plug-and-Play System Design
Shangzhu Wang, George S. Avrunin, Lori A. Clarke, 9th International Symposium on Component-Based Software Engineering (CBSE'06), Vasteras, Sweden. Springer-Verlag Lecture Notes in Computer Science, Vol. 4063, pp. 98-113, June 29-July 1, 2006. (UM-CS-2005-34)

[ SpringerLink ] [ PDF ] [ Slides ]

Containment Units: A Hierarchically Composable Architecture for Adaptive Systems
Jamieson M. Cobleigh, Leon J. Osterweil, Alexander Wise, Barbara Staudt Lerner, 10th International Symposium on the Foundations of Software Engineering (FSE 10), Charleston, SC, pp. 159-165, November 2002. (UM-CS-2001-045)

[ PostScript ] [ PDF ]


This site is maintained by the Laboratory for Advanced Software Engineering Research.
© 2006 University of Massachusetts AmherstSite Policies