Shangzhu Wang, George S. Avrunin, and Lori A. Clarke. Plug-and-play architectural design and verification. In Rogerio de Limos, Felicita Di Giandomenico, Cristina Gacek, Henry Muccini, and Marlon Vieira, editors, Architecting Dependable Systems V, number 5135 in LNCS, pages 273–297. Springer, 2008. [ DOI | .pdf ]
In software architecture, components represent the computational units of a system and connectors represent the interactions among those units. Making decisions about the semantics of these interactions is a key part of the design process. It is often difficult, however, to choose the appropriate interaction semantics due to the wide range of alternatives and the complexity of the system behavior affected by those choices. Techniques such as finite-state verification can be used to evaluate the impact of these design choices on the overall system behavior.
This paper presents the Plug-and-Play approach that allows designers to experiment with alternative design choices of component interactions in a plug-and-play manner. With this approach, connectors representing specific interaction semantics are composed from a library of predefined, reusable building blocks. In addition, standard interfaces for components are defined that reduce the impact of interaction changes on the components’ computations. This approach facilitates design-time verification by improving the reusability of component models and by providing reusable formal models for the connector building blocks, thereby reducing model-construction time for finite-state verification.
Shangzhu Wang, George S. Avrunin, and Lori A. Clarke. Architectural building blocks for plug-and-play design. In Ian Gorton, George T. Heneman, Ivica Crnkovic, Heinz W. Schmidt, Judith A. Stafford, Clemens A. Szyperski, and Kurt Wallnau, editors, Proceedings of the 9th International SIGSOFT Symposium on Component-Based Software Engineering (CBSE 2006), number 4063 in LNCS, pages 98–113, Västerås, Sweden, June 2006. [ DOI | .pdf ]
One of the distinguishing features of distributed systems is the importance of the interaction mechanisms that are used to define how the sequential components interact with each other. Given the complexity of the behavior that is being described and the large design space of various alternatives, choosing appropriate interaction mechanisms is difficult. In this paper, we propose a component-based specification approach that allows designers to experiment with alternative interaction semantics. Our approach is also integrated with design-time verification to provide feedback about the correctness of the overall system design. In this approach, connectors representing specific interaction semantics are composed from reusable building blocks. Standard communication interfaces for components are defined to reduce the impact of changing interactions on components' computations. The increased reusability of both components and connectors also allows savings at model-construction time for finite-state verification.
Shangzhu Wang, George S. Avrunin, and Lori A. Clarke. Verification support for plug-and-play architectural design. Extended abstract in Proceedings of the Workshop on the Role of Software Architecture in Testing and Analysis, Portland, ME, July 2006, 2006. [ DOI | .pdf ]
In software architecture, components are intended to represent the computational units of the system and connectors are intended to represent the interactions between those units. Choosing the semantics of these interactions is a key part of the design process, but the wide range of alternatives from which to choose and the complexity of the behavior affected by the choices makes it difficult to get them right. We propose an approach in which connectors with particular semantics are constructed from a library of pre-defined building blocks. Changes in the semantics of a connector can be accomplished by adding new building blocks to the connector, or by removing or replacing some of its existing building blocks. In our approach, a small set of standard interfaces allows components to communicate with each other through a wide variety of connectors, so the impact on components for even substantial changes in the semantics of the connectors is minimized.
In this paper, we focus on the way this approach supports design-time verification to provide feedback about the correctness of the design. By enhancing the re-use of models of both components and connectors, this approach has the potential to significantly reduce the cost of verification as a design evolves.
Shangzhu Wang, George S. Avrunin, and Lori A. Clarke. Architectural building blocks for plug-and-play system design. Technical report, Department of Computer Science, University of Massachusetts, Amherst, 2005.
One of the distinguishing features of distributed systems is the importance of the interaction mechanisms that are used to define how the sequential components interact with each other. Given the complexity of the behavior that is being described and the large design space of various alternatives from which to choose, choosing appropriate interaction mechanisms is usually difficult. In this paper, we propose a compositional specification approach that facilitates experimentation with alternative interaction semantics. In this approach, connectors representing specific interaction semantics are composed from predefined building blocks and a standard component interface and protocol are defined. Such an approach reduces the impact of change, since components often do not have to change when the interaction semantics are changed. This approach also facilitates design-time verification, since abstract models of the unchanged components and of the building blocks can often be reused. We evaluate our approach by defining building blocks for a family of message passing mechanisms and present several versions of an example that use different message passing semantics from this family. The example illustrates how this approach supports "plug-and-play" system design and verification.
Gleb Naumovich, George S. Avrunin, Lori A. Clarke, and Leon J. Osterweil. Applying static analysis to software architectures. In Mehdi Jazayeri and Helmut Schauer, editors, Software Engineering—ESEC/FSE '97, volume 1301 of Lecture Notes in Computer Science, pages 77–93, Zurich, September 1997. Springer Verlag. [ DOI | .pdf ]
In this paper we demonstrate how static concurrency analysis techniques can be used to verify application-specific properties of an architectural description. Specifically, we use two concurrency analysis tools, INCA, a flow equation based tool, and FLAVERS, a data flow analysis based tool, to detect errors or prove properties of a Wright architectural description of the gas station problem. Although both these tools are research prototypes, they illustrate the potential of static analysis for verifying that architectural descriptions adhere to important properties, for detecting problems early in the lifecycle, and for helping developers understand the changes that need to be made to satisfy the properties being analyzed.
This file was generated by bibtex2html 1.99.Back to George Avrunin's home page