=Paper=
{{Paper
|id=Vol-1723/2
|storemode=property
|title=Towards a Meta-Model for Quality-aware Self-Adaptive Systems Design
|pdfUrl=https://ceur-ws.org/Vol-1723/2.pdf
|volume=Vol-1723
|authors=Esma Maatougui,Chafia Bouanaka,Nadia Zeghib
|dblpUrl=https://dblp.org/rec/conf/models/MaatouguiBZ16
}}
==Towards a Meta-Model for Quality-aware Self-Adaptive Systems Design==
https://ceur-ws.org/Vol-1723/2.pdf
Towards a Meta-Model for Quality-aware Self-
Adaptive Systems Design
Esma Maatougui, Chafia Bouanaka, Nadia Zeghib
LIRE Laboratory
University of Constantine 2-Abdelhamid Mehri
Constantine, Algeria.
esma.maatougui@univ-constantine2.dz, chafia.bouanaka@univ-constantine2.dz, nadia.zeghib@univ-constantine2.dz
Abstract—Self-adaptation is a promising technique to manage key issue to be faced concerns the assessment of self-adaptive
software systems maintainability and evolution. A self-adaptive systems effectiveness, in terms of their ability to meet the
system is able to adapt its structure and behavior autonomously required QoS under different context conditions. In particular,
at run-time in response to changes in the context in which it is this assessment should take into account the cost of the
actually running to achieve particular quality goals. However,
adaptation process itself. Since, adapting a system can require
designing and verifying quality-aware self-adaptive systems
remains a challenging task. In this paper, we propose a formal time and system resources to be carried out, and this cost could
approach that combines the advantages of both component- even outweigh the potential benefit [3]. In addition to
based modeling (e. g., reduces model complexity), MDE (e. g., component-based software engineering (CBSE) [4], Model-
facilitates the development process) and Maude (a formal driven engineering (MDE) [5] is an emerging approach to
language) to define a development process for quality-aware self- address these and other challenges.
adaptive software. We particularly focus on the specification of MDE advocates the use of models, not only for capturing
quality-aware adaptation strategies required to ensure high-level design ideas and documenting the final product, but
continuous satisfaction of non-functional requirements (Quality as key artefacts throughout the development process. The goal
of service).
is to reduce the development time and efforts, and to
Index Terms— Self-adaptive systems; QoS; Component-Based increase product quality by raising the level of abstraction
Software Engineering; Model-Driven Engineering; Maude. and automating some time consuming and error prone
activities, e.g., by generating code directly from detailed
I. INTRODUCTION models instead of implementing it manually [6].
One major advantage of MDE is the opportunity to
Nowadays, users extensively rely on software systems automatically transform design models into analytical ones,
quality, especially in the presence of parametric and variable thus enabling formal verification of system properties;
execution contexts. However, ensuring the required qualities including non-functional ones. A largely adopted approach is
of software systems that might operate in dynamic the combination of MDE and formal methods to ensure and
environments, poses severe engineering challenges, since they guarantee functional correctness of the adaptation logic. This
must become more versatile, flexible, resilient, dependable, provides a rigorous means for modeling, specifying and
energy-efficient, recoverable, customizable, configurable, and reasoning about self-adaptive systems’ behavior, both at design
self-optimizing by adapting themselves to changes that may time and at runtime.
occur in their operational contexts, environments and system A variety of research work has been realized and significant
requirements. Self-adaptation [1] is generally considered as a efforts invested to propose models for QoS-aware self-adaptive
promising solution to manage the complexity of such software systems. However, existing techniques for non-functional
systems since it enables the system to adapt itself to internal properties analysis rely on very specific quality-related
dynamics and changing conditions in the runtime environment formalisms such as Petri Nets (PNs), or Markovian models, but
to achieve particular quality goals automatically. software systems are rarely represented in these terms [3].
A key characteristic of self-adaptive systems engineering is Besides, most of these approaches do not take into account the
to provide guarantees about the required runtime quality separation of concerns between user requirements in terms of
properties. Nevertheless, the central role of QoS requirements QoS contract and system QoS parameters. Moreover,
has to be considered at the early stages of design. Hence, the designers, who usually lack sufficient experience in
emergence of the software system architecture provides the requirements engineering, prefer design-oriented formalisms
right level of abstraction, sets the basis to achieve both such as UML [7] which reflects more the modeling intent.
functional and non-functional requirements, and needs to be
supported by methodologies and tools to capture these two In this paper, we present a component-based contractual
dimensions of the product at the same time which generally can approach to define a model for designing, specifying and
deal with the challenges of self-adaptation [3]. The component- verifying self-adaptive systems with respect to QoS contracts.
based approach can provide an appropriate level of abstraction To address this problem, we define a model for QoS contracts
to describe dynamic changes in a system structure and increase as a natural and effective way for user requirements.
the reusability and portability of software pieces. However, a
The remainder of the paper is organized as follows. Section model reusability and maintainability. Our model for quality-
2 discuses some models for self-adaptive systems that are aware self-adaptive systems provides a clear satisfaction of
relevant to our work. Section 3 is dedicated to the presentation QoS contacts by applying adaptation strategies in case of
of our model and the generation of the corresponding formal violation of QoS constraints.
specification. Section 4 illustrates our proposal via a case
study to validate our model. Finally, Section 5 rounds up the III. A COMPONENT-BASED CONTRACTUAL
paper. APPROACH FOR SELF- ADAPTIVE SYSTEMS
II. RELATED WORK
We adopt a component-based contractual approach to
A variety of models for Self-adaptive systems have been define a model for designing and formally specifying self-
proposed and various modeling methodologies have been adaptive systems with respect to QoS contracts CBSE can help
adopted, including MDE [7, 8], requirements engineering [9] in the development of self-adaptive software in two ways.
and component-based development [12]. First, it is easier to design and implement adaptable software
Vogel and Giese [8] propose a MDE-based model for Self- relying on component models. Second, the adaptation engine
Adaptive Software with EUREMA approach that realizes self- needs to be modular and reusable. Additionally, CBSE can
adaptation using the so-called executable runtime mega- also be adopted in the development phase of the self-adaptive
models. In [7], a UML-based modelling language called Adapt system. However, the Component-oriented paradigm still
Case Modeling Language (ACML) is presented. The language requires comprehensive and sound QoS contract-aware self-
allows a separate and explicit specification of self-adaptivity adaptation theories, models and mechanisms further
concerns using the concept of the MAPE-K loop. Based on trustworthy, extensible and reusable in order to realize its
formal semantics, they apply quality assurance techniques to contract. Moreover, in the CBSE vision, contracts play a
the modeled self-adaptive system. fundamental role, as they must capture the functional and
Brown and Cheng [9] adopt a Goal-Oriented Requirements extra-functional user requirements.
Engineering to present the Awareness-Requirement and We define a QoS-aware component-based model for self-
propose a way to elicit and formalize such requirements using adaptive systems where context and functional entities are
the OCL language. A methodology for generating feedback viewed as components that interact via adaptation strategies,
from such requirements, as well as fragments of a prototype and designed in an entirely independent manner and only
implementation founded on an existing requirements relationships between them are specified, thereby simplifying
monitoring framework is proposed. Elkodary et al. present an the adaptation mechanisms. To achieve this goal, we model an
approach, named FUSION [10], which uses feature diagrams adaptation strategy as a pair of elements: an action associated
as a system model where self-adaptation is realized by with the notification of events that violate their contracted
switching between different system configurations. The self- QoS constraints. The adaptation strategy adapts system
adaptation in FUSION is goal-driven, i.e., relying on functionalities according to context changes in terms of
predefined functional or non-functional goals. Each goal variations on system structure and/or behavior.
consists of a metric and a utility. While the metric is a The model is designed with a focus on the separation of
measurable entity as response time, a utility is a feature which concerns between the specification of QoS parameters;
has influence on the metric, and is triggered when FUSION defining user quality requirements, and software components
detects that a goal is violated. The violation of a goal is quality parameters (see Figure 1). The first ones are specified
detected via defined monitoring functions. in the QoS contract while the second ones are directly defined
DYNAMICO [11] is a reference model for engineering of the component specification.
adaptive software aligned with the vision of self-adaptive
systems, where dynamic adaptation is necessary to ensure the
continuous satisfaction of their functional requirements while
preserving the predefined conditions on Quality of Service
levels. These QoS levels are usually represented in the form of
Service Level Agreements (SLAs), and their enforcement
mechanisms are based on contracts and policies. Castaneda
Bueno designs a component-based reference architecture [12]
with distribution and extensible capabilities for self-adaptive
systems according to the reference model DYNAMICO.
In the present work, we propose a component-based
Figure. 1. An Overview of the proposed model.
contractual approach for quality-aware self-adaptive software
systems specification that supports system and QoS contracts QoS contracts comprise a number of quality of service
modeling together with the corresponding adaptation logic. The constraints that might be satisfied and preserved by a managed
proposed approach defines QoS constraints in an independent system. These QoS constraints are specified for each of the
way from system QoS parameters. This separation of different context conditions that the managed system is faced
concerns reduces system modeling complexity and increases with while it is running. Thus, the continuous satisfaction of a
QoS contract (i.e., its preservation) implies satisfying each of meta-class defines anything that interacts and affects the target
the QoS constraints that the user expects, under each of the or functional system. The Context is defined by its ContextID
corresponding varying conditions of execution contexts. At and the corresponding possible values.
runtime, once these conditions actually occur in the execution
context of the managed application, the respective QoS C. The third part contains the AdaptationStrategy meta-
constraints must be monitored, and their fulfillment enforced. class, which represents scenarios of adaptation that will be
To be able to automatically ensure QoS contracts, a applied in the case of violation of the QoS Constraints. These
component-based self-adaptive system requires (i) to maintain scenarios are defined by a set of adaptation rules that can be
a structural representation of itself (ii) to have a representation of the following types: (i) add a component to the actual system
of the contracted QoS constraints under the different context configuration, (ii) remove a component, and (iii) replace one
conditions; (iii) to be self-monitoring, that is, to identify and component by another.
notify events on the QoS constraints violations; and (iv) to
apply the dynamic reconfiguration in response to events D. The last part of the meta-model contains necessary
notifying imminent violation of QoS constraints, as specified in concepts to define the functional system configuration, viewed
the QoS contracts. as a set of components which require or provide services to
Based on the previous considerations, we build our each other through specific interfaces. These components are
component-based QoS-aware model for self-adaptive systems. represented by the Component meta-class and defined by a
We first present our meta-model-based definitions for name specified in the CName attribute. A component
component-based self-adaptive software structure and QoS comprises a set of Quality attributes (quality attributes of the
contracts respectively. Then, we define transformation rules to running service), and a set of provided interfaces
be applied to generate automatically a Maude formal (ProvidedInterface) and Required ones (RequiredInterface).
specification of models instantiating the already defined meta- Each interface exposes a set of services that are required or
model. provided by the component. Connections in our model are
3.1. Model-based self-adaptive systems design dynamic and only established whenever one component is
providing the service and the other one is requesting it.
Our model exploits the MDE techniques to provide a
solution for self-adaptation via meta-models which describe 3.2. Model Transformation for Generating Maude
concepts that can be used for constructing models that conform specifications
to its definition, and describes in an abstract way, the possible
structure of the underlying models. The meta-model of Figure Albeit, MDE tries to facilitate software development and
2, specifies the various concepts that intervene to define the simplify the design process by specifying meta-models
structure of quality-aware self-adaptive systems together with focusing on the structural and static semantics of software
their pertinent relationships. It is structured in four parts: systems, it lacks necessary concepts to define the semantics or
behavior of software systems and thus verification
A. The first part contains four meta-classes representing a mechanisms that are among the major issues in specifying
quality of service contract. A QosContract is defined by its self-adaptive systems. A reasonable and desirable formal
name and a set of QoS properties. A QoS property denotes a method to be adopted for this scope should be powerful
specific non-functional characteristic of the considered system enough to capture the principal models of computation and
such as its performance, reliability, and cost. A QoSproperty specification methods, and endowed with a meta-model-based
is defined by a name and a weight reflecting the relative definition conforming to the underlying meta-modeling
importance of the QoSproperty with regards to the user framework. Additionally, the formal approach should allow
preferences. To facilitate the specification of user preferences, working at different levels of abstraction, and be executable,
three weight values are predefined in the Weight Enumeration in order to validate the meta-model semantics. Rewriting logic
(high, low, medium). Each QosProperty needs one or more [14] via its implementation language Maude [15] is an
metrics to be quantitatively measured. A QosMetric, defined adequate candidate for the definition of the semantics basis of
by its idMetric, represents a non-functional property which our meta-model for many reasons. First, the versatility of
belongs to a domain of values as response time. Finally, we rewrite theories can offer the appropriate level of abstraction
associate a QosConstraint to the entire or a subset of QoS for addressing the specification, modelling and analysis of
properties in different conditions of context. In general, a self-adaptive systems and their environment within one single
QosConstraint consists of a relational operator (e.g., <, >, =) coherent framework. Second, since Maude is a rule-based
and a value representing a threshold. language, the adaptation logic can be naturally expressed as a
B. The second part contains two meta-classes subset of the available rules, and the meta-programming
representing context sensors used to model context sources and capability of Maude can be exploited to enforce the execution
values. The ContextSensor meta-class is defined by its of a given adaptation rule to maintain QoS parameters via
SensorID and sensor type. Three types of sensors are identified Maude strategies. Third, the formal analysis toolset of Maude
in [13] : Physical, Virtual and Logical sensors. Sensor types are can support simulations and analysis over the self-adaptive
represented via the SensorTypes Enumeration. The Context system.
A B
C D
Figure 2.Self-adaptive system meta-model.
The bridge between MDE and formal methods is Strategies respectively. The first mapping of Table 1 concerns
established via model transformation techniques, realized via a structural concepts that can be defined as an Acceleo template
set of transformation rules. A model transformation consists in as follows:
general of a computation that applies repeatedly a set of
transformation rules to a model, where the model represents [template public generateElement(Package : EPackage)]
the structure of a sentence in a given formal language, defined [comment @main/]
[file (Package.name.concat('.maude'), false, 'UTF-8')]
by a meta-model. EMF (Eclipse Modeling Framework) [16] (omod [Package.name.toUpperFirst()/] is
and specially Acceleo [17] are used in our case as a modeling for (c: EClass | Package.eAllContents(EClass))
framework and code generator implementation of the OMG’s separator('\t')]
Model-to-text specification for building tools and applications [if c.name.equalsIgnoreCase('AdaptationStrategy')=
false)]
based on models defined in the Ecore meta-model. This tool [if(c.name.equalsIgnoreCase('AdaptationRule')=
provides the capability to define advanced code generators for false)]
transforming models to a target code by defining class [c.name.toString()/] | [for (a: EAttribute
transformation templates. |c.eAttributes ) separator(',')] [a.name/] :
[if (a.eAttributeType.name='EString')]String [/if]
[if (a.eAttributeType.name<>'EString')]
Table 1 illustrates some results of transformation rules [a.eAttributeType.name/] [/if] [/for]
defined between the self-adaptive meta-model and the formal [if (c.eReferences<>null)] ,
semantics. The meta-model and the imposed constraints [c.eReferences->first().name/] [/if] : OidList.
provide the capability to achieve a formal specification [/if]
[/if]
generation through template models. Our goal is to transform [/for]
EClass, EAttribute, EReference and EOperation of the self- endom)
adaptive model to Maude constructs to facilitate self-adaptive [/file]
systems specification. [/template]
The template for structural concepts generates a Maude file,
Since Maude offers two possible representations, the
using a tag [file] to specify the output file, that contains the
algebraic and the object-oriented ones, we have adopted an
various classes and their attributes as specified in Table 1. It
object-oriented representation in order to reflect the
begins by testing if the considered element is not a behavioral
hierarchical structure of self-adaptive systems and avoid the
concept, i.e., neither an adaptation rule nor an adaptation
flat structure while adopting algebraic terms. In addition, all
strategy. Such verification is realized via the conditional
structural concepts are transformed to Maude classes while
statement [if]. Then, it generates a class from each EClass of
behavioral concepts as Adaptation Rules and Adaptation
the meta-model via the [for] bloc, together with the
Strategies are transformed to rewriting rules and Maude
corresponding attributes.
TABLE 1. Transformation results.
Structural concepts
Eclass Maude specification
QosContract class QosContract | name : String , QosProperties : OidListe .
QosProperty class QosProperty | name : QosPropertyName , Weight : Weight , Qosmetrics : OidListe .
QosMetric class QosMetric | idMetric : String , QosContraints : OidListe .
class QosConstraint | value : Float , operator : String , contextValue : Oid.
QosConstraint
FonctionnelSys class FonctionnelSystem | Components : OidListe .
Component class Component | Cname : String , QualityAttribute : Oid , ProvidedInterfaces : OidListe ,
RequiredInterfaces : OidListe .
class ProvidedInterface | ProvidedServices : OidListe .
ProvidedInterface
class RequiredInterface | RequiredServices : OidListe .
RequiredInterface class Service | Servicename : String ,QualityAttribute : Oid , isActive : Bool ,Parameters :
Service OidListe.
class QualityAttribute | name : String , value : Float .
Behavioral concepts
AdaptationRule crl [ReplaceComponent] :
< F : FonctionnelSystem | Components : C CL >
< C : Component | Cname : name , QualityAttribute: Q1 ,ProvidedInterfaces: I PIL ,RequiredInterfaces
: RIL >
< C' : Component |Cname: name2 ,QualityAttribute: Q2 ,ProvidedInterfaces: IL ,RequiredInterfaces: L >
< Q1 : QualityAttribute | name : QN , value : V1 >
< Q2 : QualityAttribute | name : QN , value : V2 >
=>
< F : FonctionnelSystem | Components : (del(C, (add(C' , CL )) )) >
< Q2 : QualityAttribute | >
< C' : Component |Cname: name2 ,QualityAttribute: Q2 ,ProvidedInterfaces: IL , RequiredInterfaces: L
>
if V2 < V1 .
AdaptationStrategy (fmod SelfAdapt-STRA is
pr REW-SEQ .
op SelfAdaptStrat : -> List{Tuple{Qid, Substitution}} [memo] .
eq SelfAdaptStrat = ('ReplaceComponent, 'F:Oid <- ''F.Qid ; 'C:Oid <- '' FireManComp.Qid ;
'C':Oid <- '' FireEngComp.Qid ) .
IV. MOTIVATING ADAPTATION SCENARIO adaptation objectives, we should identify detectable contexts
reflecting the software running state or physical
The scenario of a firefighting system [18, 19] is used as environment, and then identify adaptive actions that can be
an example. Fire fighters often work in dangerous and performed at runtime to change the system behavior. In this
dynamic environments. Moreover, a fire accident is one of example, the detectable fire signals (contexts) are various,
the most frequent incident types. The early detection and such as CO, CO2, along with high temperature, and strong
timely preventive measures are effective methods for flame. Therefore, the context to be chosen depends on the
limiting fire damage and reducing casualties. In this occurring place and the fire disaster type.
example, the firefighting system is a component-based
software system designed to detect fire signals and make Self-adaptive Firefighting System is used to monitor
effective fire-management strategies. When fire danger indoor fire disasters. It is composed of two essential parts,
occurs, these components dynamically restructure into a see Figure 3: context layer and functional one. We identify
firefighting plan by choosing appropriate firefighting Temperature, Smoke Concentration, CO Concentration and
resources from the component library. These well- Infrared Wavelengths as different contexts. The
restructured components then drive the corresponding fire- corresponding Maude specification of the available contexts
extinguishing installations to perform the firefighting plan. is given by the following fragment of code:
The Firefighting System automatically takes effective < 'CTXS1 : ContextSonsor | SonsorID : "FireMonitor_TEM" , Type :
measures to prevent the fire disaster (Goal). This goal can be PhysicalSonsor , context : 'CTX1 >
further decomposed into: (G1) detect fire signals in the early < 'Temperature : Context | ContextID : "Temperature" ,ContextValue : "65" >
< 'CTXS2 : ContextSonsor | SonsorID : "FireMonitor_CO" , Type :
stage and (G2) assemble a set of fire-fighting devices in
PhysicalSonsor , context : 'CTX1 >
response to a real-time fire situation. To achieve these self- < 'CO-Con : Context | ContextID : "CO-Con" , ContextValue : "70%" >
Figure 3. Self-adaptive Firefighting System model.
We also identify three types of components: Fireman, this QosContract is given by the following fragment of
Fire Engine and Extinguisher. In the example, fire- code:
prevention measures are made by dynamically restructuring
the firefighting components. The corresponding Maude < 'QosContract : QosContract | name : "FireFighting" , QosProperties : 'P1 >
specification of these components is given by the following < 'P1 : QosProperty | name : "Performance" , Weight : hight , Qosmetrics :
'M >
fragment of code:
< 'M : QosMetric | idMetric : "ResponseTime" , QosContraints : 'C1 'C2 >
< 'C1 : QosConstraint | value : 30.0 , operator : "<" , contextValue :
< 'F : FonctionnelSystem | Components : 'FireManComp 'ExgComp > 'Temperature >
< 'C2 : QosConstraint | value : 20.0 , operator : "<" ,contextValue : 'Co-Con >
< 'FireManComp : Component | Cname : "FireMan" , QualityAttribute : 'Q1 ,
ProvidedInterfaces : 'FM_Interface >
< 'FireEngComp : Component | Cname : "FireEngineComp" , QualityAttribute As an example of adaptation strategies application, we
: 'Q2 , ProvidedInterfaces : 'FE_Interface > consider the case of a violation of the response time in the
< 'ExgComp : Component | Cname : "Extinguisher_Comp" , QualityAttribute : Temperature context by the actually running component
'Q3 , ProvidedInterfaces : 'EX_Interface > "FireManComp". In this case, the system detects a violation
< 'FM_Interface : ProvidedInterface | ProvidedServices : 'StartCompFM > of QoS Constraint and applies the adaptation strategy that
< 'FE_Interface : ProvidedInterface | ProvidedServices : 'StartCompFE > replaces the "FireManComp" by "FireEngineComp"
< 'EX_Interface : ProvidedInterface | ProvidedServices : 'StartCompEX >
component. Figure 4 shows the result of the adaptation
< 'StartCompFM : Service | Servicename : "StartCompFM" , QualityAttribute :
strategy. "FireEngineCom” component that respects the
'Q1 , isActive : true , Parameters : 'PL >
QosConstraint “C1” (reponse time of FireEngineComp =
< 'StartCompFE : Service | Servicename : "StartCompFE" , QualityAttribute :
Q2 , isActive : false , Parameters : 'PL >
20ms), is added to the list of components in the functional
< 'Q1 : QualityAttribute | name : "ResponseTime" , value : 50.0 >
system and its service “StartCompFE” becomes running
< 'Q2 : QualityAttribute | name : "ResponseTime" , value : 20.0 > (isActive : true). It replaces “FireManComp” which does
not meet the quality requirements.
The “FireManComp” component has “Q1” as a quality
Maude> …
attribute which represents the response time of 50 sec and a Introduced module SelfAdapt-STRA
Provided Interface “FM_Inerface” that proposes a unique
running service “StartCompFM”. result Configuration : …
< 'F : FonctionnelSystem |
Components :('ExgComp 'FireEngComp)> <
In the firefighting system, we are concerned with the 'FE_Interface : ProvidedInterface | ProvidedServices :
analysis of the performance quality parameters in terms of 'StartCompFE >
the response. For this reason, we identify the < 'FireEngComp : Component | Cname :
Firefighting_Contract which comprises the Performance "FireEngineComp",ProvidedInterfaces :
'FE_Interface,QualityAttribute : 'Q2 >
as a QosProperty and ResponseTime, see Figure 3, as a
< 'StartCompFE : Service | Parameters : 'PL,
metric that is used to evaluate the performance. We propose QualityAttribute : 'Q2, Servicename : "StartCompFE",
two QosConstraint in this example: The response time in the isActive : true > < 'StartCompFM : Service | Parameters
Temperature context must not exceed 30 sec. But, in the : 'PL, QualityAttribute : 'Q1,Servicename :
context of CO-Concentration, the response time might not “StartCompFM",isActive : false >
exceed 20 sec. The corresponding Maude specification of
Figure. 4. A strategy application result.
V. Conclusion International Symposium on Software Engineering for
Adaptive and Self-Managing Systems , ser. SEAMS ’2013.
[8] T. Vogel and H. Giese. Model-driven engineering of self-
In this paper, we have proposed a component-based adaptive software with EURUMA. ACM Trans. Auton Adapt.
contractual approach for designing and specifying self- Syst., Jan. 2014.
adaptive systems with respects to Quality of Service [9] Brown, G., Cheng, B.H., Goldsby, H., Zhang, J.: Goal-
contracts. The approach establishes a clear separation of oriented specification of adaptation requirements engineering
concerns between the specification of user definable QoS in adaptive systems. In: ACM 2006 , Shanghai, China, 2006.
quality parameters and quality parameters of the software [10] A. Elkhodary, N. Esfahani, and S. Malek. FUSION: a
framework for engineering self-tuning self-adaptive software
components. To implement the proposed approach, we have systems. In Proceedings of the eighteenth ACM SIGSOFT
combined the MDE techniques and a formal method in international symposium on foundations of software
order to provide an intuitive modeling notation, supporting a engineering, FSE '10, pages 7-16, New York, NY, USA,
graphical view, but still having a rigorous syntax and 2010.
semantics. Such combination also facilitates the use of [11] N. M. Villegas, G. Tamura, H. A. M̈uller, L. Duchien, and R.
Casallas, DYNAMICO: A Reference Model for Governing
formal methods in many stages of the development process Control Objectives and Context Relevance in Self-Adaptive
including the analysis phase that includes validation and Software Systems , ser. LNCS. Springer, 2013.
verification techniques. [12] L.Castaneda Bueno, A Reference Architecture for
As future work, we intend to exploit main characteristics of Component-Based Self-Adaptive Software Systems. Magister
Graduation Project. Department of Information and
formal methods to rigorously verify the behaviors of model- communication Technologies Faculty of
based self-adaptive systems, formal specifications are Engineering.Universidad ICESE. 2012
automatically generated. We will mainly adopt a stochastic [13] J. Zhang and B. Cheng. Model-based development of
model-checking technique to ensure quality properties of dynamically adaptive software. In 28th International
self-adaptive systems. Besides, we plan to develop a Conference on Software Engineering . ACM, 2006
modeling tool that facilitates the creation and the [14] Meseguer, J., Conditional rewriting logic as a unified model
of concurrency. Theor. Comput. Sci. 96 (1), 73–155. 1992.
implementation of quality-aware self-adaptive systems. We
[15] Clavel, M., Durn, F., Eker, S., Lincoln, P., Mart-oliet, N.,
aim to integrate formal techniques within the MDE ones. Meseguer, J., Talcott, C.,. Maudemanual.version 2.6. 2011
The role of MDE is the definition of system graphical [16] Steinberg D, Budinsky F, Paternostro M, Merks E, Eclipse
models and formal methods serve to validate and verify the EMF. Modeling framework. 2nd editionAddison-Wesley;
self-adaptive system in order to guarantee that system model 2009.
satisfies global properties and particularly quality ones. [17] http://www.eclipse.org/acceleo.
Furthermore, we aim to apply our approach on [18] D Han, Q Yang, J Xing, J Li, H Wang, FAME: A UML-based
framework for modeling fuzzy self-adaptive software, Article
supplementary case studies in the goal of optimizing the in Information and Software Technology. April 2016.
existing quality properties modeling, the verification and
[19] C An, Y Luo, A Timm-Giel.Adaptive Routing in Wireless
implementation capabilities of the self-adaptive systems Sensor Networks for Fire Fighting. - Information and
modeling framework. Communication Technologies, Springer, 2012.
ACKNOWLEDGMENTS
This work is published through funding provided under
the CMEP/TASSILI project N°08MDU945.
REFERENCES
[1] R. Laddaga , P. Robertson , Self-adaptive software: a position
paper, in: Proceed-ings of International Workshop onSelf-Star
Properties in Complex Information Systems, Bertinoro, 2004.
[2] Cheng, B., et al. . Software Engineering for Self-Adaptive
Systems: A Research Roadmap. Software Engineering for
Self-Adaptive Systems, 2009.
[3] V.Grassi, R.Mirandola, E.Randazzo, Model-Driven
Assessment of QoS-Aware Self-Adaptation, Software
Engineering for Self-Adaptive Systems, 2009.
[4] George T. Heineman and William T. Councill, editors.
Component-Based Software Engineering: Putting the Pieces
Together. Addison-Wesley Longman, 2001.
[5] R. da Silva, Model-driven engineering: a survey supported by
a unified conceptual model, Comput. Lang. Syst. Struct. 2015.
[6] J.Carlson & al. Deployment Modelling and Synthesis in a
Component Model for Distributed Embedded Systems; 2010.
[7] M. Luckey and G. Engels, “High-quality specification of self-
adaptive software systems,” in Proceedings of the 8th