31 research outputs found
mRUBiS: An Exemplar for Model-Based Architectural Self-Healing and Self-Optimization
Self-adaptive software systems are often structured into an adaptation engine
that manages an adaptable software by operating on a runtime model that
represents the architecture of the software (model-based architectural
self-adaptation). Despite the popularity of such approaches, existing exemplars
provide application programming interfaces but no runtime model to develop
adaptation engines. Consequently, there does not exist any exemplar that
supports developing, evaluating, and comparing model-based self-adaptation off
the shelf. Therefore, we present mRUBiS, an extensible exemplar for model-based
architectural self-healing and self-optimization. mRUBiS simulates the
adaptable software and therefore provides and maintains an architectural
runtime model of the software, which can be directly used by adaptation engines
to realize and perform self-adaptation. Particularly, mRUBiS supports injecting
issues into the model, which should be handled by self-adaptation, and
validating the model to assess the self-adaptation. Finally, mRUBiS allows
developers to explore variants of adaptation engines (e.g., event-driven
self-adaptation) and to evaluate the effectiveness, efficiency, and scalability
of the engines
Issues in the Runtime Modification of Software Architectures
Existing software architecture research has focused on static architectures, where the system architecture is not expected to change during system execution. We argue that the architectures of many systems, especially long running or mission critical systems, evolve during execution, and thus cannot be accurately modeled and analyzed using static architectures. To overcome these problems, we propose the use of dynamic architectures, where the system architecture may change during execution. In this paper, we identify the issues involved in supporting dynamic architectures. Although some of these issues may be addressed by augmenting current models (i.e., adding constructs that support dynamism to existing architectural description languages), many are new to dynamic architectures (i.e., runtime support for modifying architectures). We describe an initial implementation of our tool, ArchShell, that supports the runtime modification of C2-style software architectures.
Recommended from our members
Issues in the runtime modification of software architectures
Existing software architecture research has focused on static architectures, where the system architecture is not expected to change during system execution. We argue that the architectures of many systems, especially long running or mission critical systems, evolve during execution, and thus cannot be accurately modeled and analyzed using static architectures. To overcome these problems, we propose the use of dynamic architectures, where the system architecture may change during execution. In this paper, we identify the issues involved in supporting dynamic architectures. Although some of these issues may be addressed by augmenting current models (i.e., adding constructs that support dynamism to existing architectural description languages), many are new to dynamic architectures (i.e., runtime support for modifying architectures). We describe an initial implementation of our tool, ArchShell, that supports the runtime modification of C2-style software architectures
Decentralized Software Evolution
We define decentralized software evolution as the ability to evolve software independent of the original software vendor. Decentralized software evolution (DSE) provides..
Decentralized software evolution
Developers frequently confront a dilemma that may be characterized by the following: “90 % of the functionality requested by our customer is available in an existing off-the-shelf application, but the missing 10 % is vital to the customer. Unfortunately, we cannot customize or adapt the existing application to meet our customer’s needs—we have no choice but to buid a custom solution from scratch.
Reuse of off-the-shelf components in C2-style architectures
Abstract-- Reuse of large-grain software components offers the potential for significant savings in application development cost and time. Successful component reuse and substitutability depends both on qualities of the components reused as well as the software context in which the reuse is attempted. Disciplined approaches to the structure and design of software applications offers the potential of providing a hospitable setting for such reuse. We present the results of a series of exercises designed to determine how well “offthe-shelf” components could be reused in applications designed in accordance with the C2 software architectural style. The exercises involved the reuse of two user-interface constraint solvers, two graphics toolkits, a World Wide Web browser, and a persistent object manager. A subset of these components was used to construct numerous variations of a single application (thus an application family). The exercises also included construction of a simple development environment for locating and downloading a component off the Web and incorporating it into an application. The paper summarizes the style rules that facilitate reuse and presents the results from the exercises. The exercises were successful in a variety of dimensions; one conclusion is that the C2 style offers significant reuse potential to application developers. At the same time, wider trials and additional tool support are needed. 1 Index Terms-- software reuse, architectural styles, messagebased architectures, component-based development, graphical user interfaces (GUI)
Architecture-based runtime software evolution
Continuous availability is a critical requirement for an important class of software systems. For these systems, runtime system evolution can mitigate the costs and risks associated with shutting down and restarting the system for an update. We present an architecture-based approach to runtime software evolution and highlight the role of software connectors in supporting runtime change. An initial implementation of a tool suite for supporting the runtime modification of software architectures, called ArchStudio, is presented.
Recommended from our members
On the role of connectors in modeling and implementing software architectures
Software architectures are software system models that represent the design of a system at a high level of abstraction. A software architecture typically focuses on the coarse-grained organization of functionality into components and on the explicit representation and specification of inter-component communication. A notable feature of many architectural models (and the languages used to express them) is their representation of communication concerns in explicit model elements, which are typically called connectors. However, there is little consensus yet in the software engineering community on the role of connectors in an architectural model, or even on the necessity of making them first-class model elements. In this paper we demonstrate the utility of explicit connectors in architectural models through a presentation and analysis of an architecture for a meeting scheduler system. We show how the functional abstraction provided by connectors contributes to the mobility, distribution and extensibility of the design, as well as its ability to sustain run time structural change. Furthermore, we demonstrate how connectors encapsulate important aspects of inter-component communication, including the number and identity of communication recipients, the policy used to select these recipients, the choice of implementation technology for the communications, and architectural constraints on component composition