Handling the Dynamic Reconfiguration of Software Architectures Using Aspects

Costa-Soria, Cristóbal; Pérez, Jennifer; Carsí, José A.

doi:10.1109/csmr.2009.33

Cited by 5 publications

(4 citation statements)

References 10 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Several other self-configuring approaches (such as TranSAT [3,4], RSA [39], PRISMA [24,25], ArchStudio [59], K-Components Architecture [31,32] and Dellarocas et al [28]) reflectively exploit software architecture to plan and realize the artifact reconfiguration but since to report their analysis will not add much more to the discussion and due to space limitation we are not describing them all in detail.…”

Section: Self-configuring: Reflecting On the Architecturementioning

confidence: 98%

Evolution as ≪Reflections on the Design≫

Cazzola

2014

Models@run.time

View full text Add to dashboard Cite

Abstract. No system escapes from the need of evolving either to fix bugs, to be reconfigured or to add new features. To evolve becomes particularly problematic when the system to evolve cannot be stopped.Traditionally the evolution of a continuously running system is tackled on by calculating all the possible evolutions in advance and coding them in the artifact itself. This approach gives origin to the code pollution phenomenon where the code is polluted by code that could never be applied. The approach has the following defects: i) code bloating, ii) it is impossible to predict any possible change and iii) the code becomes hard to read and maintain.Computational reflection by definition allows an artifact to introspect and to intercede on its own structure and behavior endowing, therefore, a reflective artifact with (potentially) the ability of self-evolving. Furthermore, to deal with the evolution as a nonfunctional concern can limit the code pollution phenomenon.To bring the design information (model and/or architecture) at runtime provides the artifact with a basic knowledge about itself to reflect on when a change is necessary and on how to deploy it. The availability of such a knowledge at run-time enables the designer of postponing the planning and the coding of the evolution to when and only when really necessary. Reflection permits to separate the evolution from the artifact and the design information allows a (semi-)automatic planning of how the artifact should evolve when necessary.In this contribution, we overview the role that reflection and design information have in the development of self-evolving artifacts. Moreover, we summarize the lesson learned as a high-level reflective architecture to support dynamic self-evolution in various contexts and we show how some of the existing frameworks adhere to such an architecture and how the kind of evolution affects their structure.

show abstract

Section: Self-configuring: Reflecting On the Architecturementioning

confidence: 98%

Evolution as ≪Reflections on the Design≫

Cazzola

2014

Models@run.time

View full text Add to dashboard Cite

show abstract

“…) (Malenfant et al, 1996) In other words, reification is the action of exposing the internal representation of a system in terms of programming entities that can be manipulated at runtime. The opposite process is called reflection 9 , which effects the changes made to the reified entities into the system. However, these definitions may induce to confusion since they do not refer to the base-level and meta-level a reflective system is characterised by.…”

Section: Computational Reflectionmentioning

confidence: 99%

“…Intercession is the ability of a program to modify its execution state. That is, it comprises the operations of a metalevel program which change the data structures and program operations of the base-level (see Figure 3 9 Some authors prefer not to use the term reflection to define the action of reflecting changes on the base-level, and use the term absorption instead. The reason is to avoid confusions with the global term of Reflection.…”

Section: Computational Reflectionmentioning

confidence: 99%

Dynamic Evolution and Reconfiguration of Software Architectures Through Aspects

Cubel

Benedí

Costa-Soria

View full text Add to dashboard Cite

Change is an intrinsic property of software. A software system, during its lifetime, may require several updates, improvements, or new features. If these change requirements are not addressed, the risk of becoming a useless system increases. In fact, this is a challenging issue of safety-and mission-critical software systems, which cannot be stopped to perform maintenance or evolution operations due to their continuous operation. To reduce the aging of these critical systems, they must be provided with mechanisms enabling their dynamic evolution, i.e. the support of changes on their structure and behaviour while they remain in operation.This thesis is concerned with the design of a framework to build architecturebased, dynamically evolvable, software systems. The fact that this framework is a software architecture based approach provides the following advantages: (i) it offers a high-level of abstraction for describing dynamic changes; (ii) it allows varying the level of system description; and (iii) it advantages from the existing support for system modelling, code-generation, and formal analysis provided by architecture description languages.The framework presented in this thesis, called Dynamic PRISMA, is characterized by the combination of two levels of dynamism: Dynamic Reconfiguration, which addresses changes at the configuration level (i.e. the architectural configuration), and Dynamic Type Evolution, which addresses changes at the type-level (i.e. the specification of architectural types and instances). This combination is one of the major contributions of this thesis: thus a system is not only able to reconfigure at runtime the building blocks it is composed of (i.e. architectural types), but also to redefine these building blocks (or introduce new ones) at runtime.Another contribution of the thesis is the identification of the concerns related to dynamic evolution and their integration in the framework through aspects. This improves the separation of concerns and allows us to change reconfiguration specifications, evolution mechanisms, or the business logic independently of each other.A third contribution of this thesis is how this dynamism is supported: reconfiguration through autonomic capabilities, which provides proactivity according to either internal or external stimuli; and type evolution through asynchronous reflection, which enables the modification of a type specification and the transformation of their instances at different rates (i.e. when they are ready for evolution). Specifically, the asynchronous evolution vi semantics is precisely described by means of graph transformations. This formalism has been chosen because it naturally models both the system architecture and its asynchronous evolution.The work presented in this thesis is illustrated through a case study from the robotics domain; an area which could potentially benefit from the results of this thesis. KEYWORDSsoftware architectures, dynamic evolution, dynamic reconfiguration, dynamic type evolution, dynamic instance evol...

show abstract

“…In exogenous dynamism, the centralization of the reconfiguration process can reduce the performance of the architecture at run-time due to bottleneck at the implementation level, what characterizes its main disadvantage. Moreover, different architectural elements can require a specific set of operations which must be described and performed independently from each other (Costa-Soria et al, 2009). On the other hand, maintainability and reuse can be decreased in the endogenous approach due to reconfiguration actions may be tangled with components's behavior/functionality.…”

Section: Management According Tomentioning

confidence: 99%

Architectural Views to the Representation of Dynamic Software Architectures

Biazotto¹

View full text Add to dashboard Cite

Presently, several critical application domains have adopted large, complex, and softwareintensive systems, whose architectural design demand special attention. Such systems, occasionally display dynamic architectures and specific structures are required for supporting changes at run-time. Moreover, many of them require high levels of reliability due to their critical domains. Towards ensuring reliability, formal languages/notations have been used to represent dynamism in software architectures, which demand efforts and time to be learned and to model architectures; besides, the resulting models are of difficult understanding. Moreover, most of these representation are incomplete, lacking some relevant information. To mitigate this problem, this Master's project proposes a set of architectural views and associate semi-formal techniques that support architects in the design of software architectures that present dynamism. This Master's project proposes a set of architectural views and associated semi-formal techniques for supporting architects in the design of software architectures that show dynamism. From results of a systematic mapping study, a conceptual model was elaborated towards delimiting the main concepts to be covered by the views. A set of fine views (general view, reconfiguration view, rippleeffect view, scenario view, and strategy view) was then defined and a proof of concept was conducted with the use of a system for the Healthcare Supportive Home Systems domain. The results show the feasibility and suitability of using the set in combination with the conceptual model and the associated techniques for representing dynamism in software architectures.

show abstract

Handling the Dynamic Reconfiguration of Software Architectures Using Aspects

Cited by 5 publications

References 10 publications

Evolution as ≪Reflections on the Design≫

Evolution as ≪Reflections on the Design≫

Dynamic Evolution and Reconfiguration of Software Architectures Through Aspects

Architectural Views to the Representation of Dynamic Software Architectures

Contact Info

Product

Resources

About