- Software Development
- Component-Based Software Engineering »
- Arcadia
- Software Development Environments
- Publications
- 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