AbstractAs modern software-based systems increase in complexity, recovery from malicious attacks and rectification of system faults become more difficult, labor-intensive, and error-prone. These factors have actuated research dealing with the concept of self-healing systems, which employ architectural models to monitor system behavior and use inputs obtaining therefore to adapt themselves to the run-time environment. Numerous architectural description languages (ADLs) have been developed, each providing complementary capabilities for architectural development and analysis. Unfortunately, few ADLs embrace dynamic change as a fundamental consideration and support a broad class of adaptive changes at the architectural level. The Architecture Dynamic Modeling Language (ADML) is being developed as a new formal language and/or conceptual model for representing dynamic software architectures. TheADML couple the static information provided by the system requirements and the dynamic knowledge provided by tactics, and offer a uniform way to represent and reason about both static and dynamic aspects of self-healing systems. Because the ADML is based on the Dynamic Description Logic DDL, architectural ontology entailment for the ADML languages can be reduced to knowledge base satisfiability in DDL

Chen, Fei

Guo, Jing

He, Hui

Wang, Zhuxiao

Wu, Kehe

Elsevier - Publisher Connector 

Procedia Engineering 29 (2012) 3909 – 3913
1877-7058 © 2011 Published by Elsevier Ltd.
doi:10.1016/j.proeng.2012.01.593
Available online at www.sciencedirect.com
Available online at www.sciencedirect.com
 
           Procedia Engineering  00 (2011) 000–000 
Procedia
Engineering
www.elsevier.com/locate/procedia
 
2012 International Workshop on Information and Electronics Engineering (IWIEE) 
An Architecture Dynamic Modeling Language for Self-
Healing Systems 
Zhuxiao Wanga*, Jing Guob, Kehe Wua, Hui Hea, Fei Chena 
aSchool of Control and Computer Engineering, State Key Laboratory of Alternate Electrical Power System with Renewable Energy 
Sources, North China Electric Power University, Beijing 102206, China 
bNational Computer Network Emergency Response Technical Team/Coordination Center of China, Beijing 100029, China 
 
Abstract 
As modern software-based systems increase in complexity, recovery from malicious attacks and rectification of 
system faults become more difficult, labor-intensive, and error-prone. These factors have actuated research dealing 
with the concept of self-healing systems, which employ architectural models to monitor system behavior and use 
inputs obtaining therefore to adapt themselves to the run-time environment. Numerous architectural description 
languages (ADLs) have been developed, each providing complementary capabilities for architectural development 
and analysis. Unfortunately, few ADLs embrace dynamic change as a fundamental consideration and support a broad 
class of adaptive changes at the architectural level. The Architecture Dynamic Modeling Language (ADML) is being 
developed as a new formal language and/or conceptual model for representing dynamic software architectures. The 
ADML couple the static information provided by the system requirements and the dynamic knowledge provided by 
tactics, and offer a uniform way to represent and reason about both static and dynamic aspects of self-healing systems. 
Because the ADML is based on the Dynamic Description Logic DDL, architectural ontology entailment for the 
ADML languages can be reduced to knowledge base satisfiability in DDL. 
 
© 2011 Published by Elsevier Ltd. Selection and/or peer-review under responsibility of Harbin University 
of Science and Technology 
 
Keywords: Architecture Description Languages; Knowledge Representation and Reasoning; Software Architecture; Dynamic 
Description Logics; Self-Healing  Systems; Dynamic Adaptation 
 
* Corresponding author. Tel.: 010-61772742; fax: +0-000-000-0000 . 
E-mail address: wangzx@ncepu.edu.cn. 
Open access under CC BY-NC-ND license.
Open access under CC BY-NC-ND license.
3910  Zhuxiao Wang et al. / Procedia Engineering 29 (2012) 3909 – 39132 Zhuxiao Wang/ Procedia Engineering 00 (2011) 000–000 
1. Introduction 
As modern software-based systems gain in versatility and functionality, an increasingly important 
requirement for software systems is the ability to modify their own behaviors in response to changes in 
their operating environment [1,2]. By operating environment, we mean anything observable by the 
software system, such as resource variability (bandwidth, server availability, etc.), changing user needs 
(high-fidelity video streams at one moment, low fidelity at another, etc.), system faults (servers and 
networks going down, etc.), and successful attacks (launched by hackers).  
In this article, we present a new approach embodied in the Self-Adaptive Software Infrastructure 
(SASI), a middleware system which enables the target system to heal themselves of system faults and to 
survive malicious attacks. An application that runs within the SASI environment appears to be self-aware, 
knowing its plans and goals. The centerpiece of the approach is the use of architectural models [3,4]. We 
need to consider some language (like the Architecture Dynamic Modeling Language, ADML) for 
describing the architecture of the target system at each point in time. Change operations (like tactics in 
ADML) are formulated in, and reasoned over, an explicit architectural model residing on the 
implementation platform. Changes to the architectural model are reflected in modifications to the 
application’s implementation, while ensuring that the model and the implementation are consistent with 
one another. 
ADML is intended as a new formal language and/or conceptual model for describing the architecture 
of a system. We describe the main features of ADML, its rationale, and technical innovations. ADML is 
based on the idea of representing an architecture as a dynamic structure and supporting a broad class of 
adaptive changes at the architectural level. However, simultaneously changing components, connectors, 
and topology in a reliable manner requires distinctive mechanisms and architectural formalisms. Many 
architecture description languages are dynamic to some limited degree but few embrace dynamic change 
as a fundamental consideration. ADML is being developed as a way of representing dynamic software 
architectures by expressing the possible change operations in terms of the ADML structures. 
ADML can be viewed as syntactic variants of dynamic description logic. In particular, the formal 
semantics and reasoning in ADML use the DDL(SHON(D)) dynamic description logic, extensions of 
description logics (DLs) [5] with a dynamic dimension [6,7]. So the main reasoning problem in ADML 
can be reduced to knowledge base (KB) satisfiability in the DDL(SHON(D)). This is a significant result 
from both a theoretical and a practical perspective: it demonstrates that computing architectural ontology 
entailment in ADML has the same complexity as computing knowledge base satisfiability in 
DDL(SHON(D)), and that dynamic description logic algorithms and implementations can be used to 
provide reasoning services for ADML. 
In the following sections, we firstly present the architecture of Self-Adaptive Software Infrastructure 
(SASI) in Section 2. Section 3 serves as an overview of the capabilities of ADML. We highlight some of 
the crucial ADML syntax with an overview of ADML semantics. We show that the main reasoning 
problem in ADML can be reduced to knowledge base (KB) satisfiability in the DDL(SHON(D)) dynamic 
description logic. Finally, we summarize the paper in Section 4. 
2. Architecture of the SASI System 
Here we present the architecture of the Self-Adaptive Software Infrastructure (SASI). The centerpiece 
of the SASI is the use of architectural models (Fig. 1). In this paradigm system’s run time behavior is 
monitored by monitors outside the running system. Monitored values are filtered, abstracted and related 
to architectural properties of an architectural model. The Architecture Manager is responsible for 
interpreting system observations. It consists of an architectural model of the system, together with a 
3911Zhuxiao Wang et al. / Procedia Engineering 29 (2012) 3909 – 3913 Zhuxiao Wang/ Procedia Engineering 00 (2011) 000–000 3 
strategy generator that verifies whether the system goals and constraints are satisfied, and if not, it can 
adapt the system using some self-healing modules. A typical strategy generator takes three inputs: the 
current system state provided by monitors, a description of the desired overall system objectives, and a set 
of preconditioned tactics, all encoded in a formal language such as ADML. The generator produces a 
sequence of tactics that lead from the current system state to a state meeting the overall system objectives. 
In our description frameworks for tactics, functional descriptions are essentially the state-based and use at 
least pre-state and post-state constraints to characterize intended executions of a tactic. The self-healing 
modules execute an appropriate repair script depending upon the tactic chosen. As a result, architectural 
changes are propagated down to the running system. 
3. ADML as the DDL(SHON(D)) Dynamic Description Logic 
ADML is intended as a new formal language and/or conceptual model for describing the architecture 
of a system. ADML is built on a core ontology of six types of entities for architectural representation: 
components, connectors, systems, ports, roles, and tactics. Of the six types, the most basic elements of 
architectural description are components, connectors, systems, and tactics. It's important to recognize that 
ADML is based on the idea of representing an architecture as a dynamic structure. In other words, ADML 
may also be used as a way of representing reconfigurable architectures by expressing the possible 
reconfigurations in terms of the ADML structures (like tactics). For example, an architectural model 
might include tactics that describe components that may be added at run-time and how to attach them to 
the current system. 
ADML is very close to the DDL(SHON(D)) Dynamic Description Logic which is itself an extension of 
the SHON(D) Description Logic (extended with a dynamic dimension). ADML can form descriptions of 
components, connectors, and systems using the constructs. Given the limited space available, in this 
article I will not delve into the details of the ADML syntax. ADML facts and tactics are summarized in 
Tab. 1 below. In this table the first column gives the ADML syntax for the construction, while the second 
column gives the DDL(SHON(D)) Dynamic Description Logic syntax.  
Because ADML includes datatypes, the semantics for ADML is very similar to that of Dynamic 
Description Logics that also incorporate datatypes, in particular DDL(SHON(D)).  
 
 
Fig. 1. Framework of the SASI 
3912  Zhuxiao Wang et al. / Procedia Engineering 29 (2012) 3909 – 39134 Zhuxiao Wang/ Procedia Engineering 00 (2011) 000–000 
Table 1. ADML facts and tactics 
ADML Syntax DDL Syntax Semantics 
Facts 
Individual( o type(C1) ... type(Cn)) o ∈ Ci o I(w) ∈ Ci I(w) 
Individual( o value(R1 o1) ... value(Rn 
on)) 
<o, oi> ∈ Ri < o I(w), oi I(w) > ∈ Ri I(w) 
Individual( o value(U1 v1) ... value(Un 
vn)) 
<o, vi>∈ Ui < o I(w), vi I(w) > ∈ Ui I(w)  
SameIndividual(o1... on) o1= ... =on o1 I(w) = ... =on I(w) 
DifferentIndividual(o1... on) oi ≠ oj, i ≠ j oi I(w) ≠ oj I(w), i ≠ j 
negationOf (ϕ) ¬ϕ (M,w)⊭ϕ 
disjunctionOf (ϕ ϕ' ...) ϕ∨ϕ’ (M,w) ⊨ϕ or (M,w) ⊨ψ 
diamondAssertion(π ϕ) <π>ϕ ∃w'∈W.((w, w')∈T(π) and (M,w') 
⊨ϕ ) 
Tactics 
Tactic (α ) α   T(α)= T(P, E)={ (w, w') | c 
(M,w)⊨ P, d (M,w)⊨ ¬ϕ for 
every ϕ∈E, e (M,w’)⊨ E, fCI(w') 
= (CI(w) ∪ {uI | C(u)∈E}) \ {uI | 
¬C(u)∈E}, and gRI(w') = (RI(w) ∪ 
{(uI, vI) | R(u, v)∈E }) \ {(uI, vI) | 
¬R(u, v)∈E}. } 
Tactic (ϕ test) ϕ? {(w, w) | w ∈ W and (M,w)⊨ϕ} 
choiceOf (π π' ...) π⋃π' T(π)∪ T(π') 
sequenceOf (π π' ...) π ; π' { (w, w') | ∃w''.(w, w'')∈T(π) and 
(w'', w')∈ T(π') } 
Tactic (π iteration) π* reflexive and transitive closure of 
T(π) 
The specific meaning given to ADML is shown in the third column of Tab. 1. A DDL(X) model 
[8,9,10] is a tuple M = (W, T, Δ, I), where, 
W is a set of states; 
T : NA→2W×W is a function mapping action names into binary relations on W; 
Δ is a non-empty domain; 
I is a function which associates with each state w ∈ W a description logic interpretation I(w) =< 
Δ, ·I(w) >, where the mapping ·I(w)  assigns each concept to a subset of Δ, each role to a subset of Δ×
Δ, and each individual to an element of Δ. 
What makes ADML an architecture description language for self-healing systems, is not only its 
semantics, which are quite standard for a dynamic description logic, but also the use of tactics for changes 
at the architectural level, the use of datatypes for data values, and the ability to use that dynamic 
description logic algorithms and implementations to provide reasoning services for ADML. 
4. Summary 
In this paper we presented ADML a new formal language and/or conceptual model for representing 
system architectures. We described the main features of ADML, its rationale, and technical innovations. 
By embracing tactics into ADML, ADML combine the static knowledge provided by the system 
requirements with the dynamic descriptions of the computations provided by repair tactics, and support 
the representing and reasoning about both static knowledge and dynamic knowledge in the self-healing 
3913Zhuxiao Wang et al. / Procedia Engineering 29 (2012) 3909 – 3913 Zhuxiao Wang/ Procedia Engineering 00 (2011) 000–000 5 
system. ADML can be viewed as syntactic variants of dynamic description logic DDL(SHON(D)). The 
functionalities of the tactics are abstracted by actions in DDL(SHON(D)), while the domain constraints, 
states, and the overall system objectives are encoded in TBoxes, ABoxes and DL-formulas, respectively. 
So the main reasoning problem in ADML can be reduced to knowledge base (KB) satisfiability in the 
DDL(SHON(D)) dynamic description logic. Afterwards, dynamic description logic algorithms and 
implementations can be used to provide reasoning services for ADML. While ADML is still too new to 
tell whether it will succeed as a community-wide tool for architectural development, we believe it is 
important to expose its language design and philosophy to the broader software engineering community at 
this stage for feedback and critical discussion. Our approach has several important advantages: self-
adaptation mechanisms can be more easily extended; they can be reasoned about independently of the 
monitored applications; they permit the application of analytical methods for deriving sound repair 
strategies; they can exploit shared monitoring and adaptation infrastructure. 
Acknowledgements 
This work is supported by the Fundamental Research Funds for the Central Universities (No.11QG13) 
and the National Science Foundation of China (No.71101048). 
References 
[1] Oreizy P, Gorlick MM, Taylor RN, Heimhigner D, Johnson G, Medvidovic N et al. An architecture-based approach to self-
adaptive software. IEEE Intell Syst 1999;14:54–62.  
[2] Kramer J, Magee J. Self-managed systems: An architectural challenge. In: Briand LC, Wolf AL, editors. Future of Software 
Engineering, New Jersey: IEEE Computer Society; 2007, p. 259–268.  
[3] Cheng S, Garlan D, Schmerl B, Sousa JP, Spitznagel B, Steenkiste P. Using architectural style as a basis for system self-
repair. In: Bosch J, Gentleman WM, Hofmeister C, Kuusela J, editors. Proceedings of the 3rd Working IEEE/IFIP Conference on 
Software Architecture, Norwell: Kluwer Academic Publishers; 2002, p. 45–59.  
[4] Garlan D, Schmerl B. Model-based Adaptation for Self-Healing Systems. In: Garlan D, Kramer J, Wolf A, editors. 
Proceedings of the first ACM SIGSOFT Workshop on Self-Healing Systems, New York: Association for Computing Machinery; 
2002, p. 27–32.  
[5] Baader F, Calvanese D, McGuinness D, Nardi D, Patel-Schneider P. The description logic handbook: theory, implementation 
and applications. Cambridge: Cambridge University Press; 2003. 
[6] Artale A, Franconi E. A temporal description logic for reasoning about actions and plans. J Artif Intell Res 1998;9:463–506.  
[7] Baader F, Lutz C, Milicic M, Sattler U, Wolter F. Integrating description logics and action formalisms: First results. In: 
Veloso MM, Kambhampati S, editors. Proceedings of the 20th National Conference on Artificial Intelligenc, California: American 
Association for Artificial Intelligence; 2005, p. 572–577. 
[8] Chang L, Shi Z, Gu T, Zhao L. A Family of Dynamic Description Logics for Representing and Reasoning About Action. J 
Autom Reasoning 2010;1–52.  
[9] Wang Z, Yang K, Shi Z. Failure Diagnosis of Internetware Systems Using Dynamic Description Logic. J Softw 
2010;21:248–260.  
[10] Wang Z, Zhang D, Shi Z. Multi-agent based bioinformatics integration using distributed dynamic description logics. In: 
Dillon T, Fox G, Zhuge H, editors. International Conference on Semantics, Knowledge, and Grid, New Jersey: IEEE Computer 
Society; 2009, p. 66–71. 


An Architecture Dynamic Modeling Language for Self-Healing Systems 

file:///data/core-remote/dit/data/elsevier/pdf/69b/aHR0cDovL2FwaS5lbHNldmllci5jb20vY29udGVudC9hcnRpY2xlL3BpaS9zMTg3NzcwNTgxMjAwNjAzMA==.pdf

An Architecture Dynamic Modeling Language for Self-Healing Systems

Abstract

Similar works

Full text

Available Versions

Elsevier - Publisher Connector