FuAET: A Tool for Developing Fuzzy Self-Adaptive Software
Systems
Qiliang Yang
1, 2
, Xianping Tao
2
, Hongwei Xie
2
, Jianchun Xing
1
, Wei Song
3
1.
College of Defense Engineering, PLA University of Science and Technology, Nanjing 210007, China
2.
State Key Laboratory for Novel Software Technology, Nanjing University, Nanjing 210093, China
3.
School of Computer Science and Technology, Nanjing University of Science and Technology, Nanjing 210094, China
yql@893.com.cn, txp@nju.edu.cn, xhw@nju.edu.cn, xjc@893.com.cn, wsong@njust.edu.cn
ABSTRACT
Handling uncertainty in software self-adaptation has become an
important and challenging issue. In our previous work, we
proposed a fuzzy control based approach named Software Fuzzy
Self-Adaptation (SFSA) to address fuzziness, a kind of uncertainty
in software self-adaptation. However, our SFSA approach still
lacks a tool to efficiently support the implementation process of
SFSA. Existing tools for realizing self-adaptive applications does
not directly deal with fuzziness in self-adaption loops. In this
paper, we present the FuAET, a tool designed for building fuzzy
self-adaptive software systems. The novelty of the tool is that it
can not only provide a friendly GUI for editing and testing fuzzy
self-adaptation strategies in intelligible domain specific language
(DSL), but also automatically convert DSL-based fuzzy self-
adaptation strategies into aspect-based programming code in
native-language (NL), e.g., C++. This paper describes the design
framework and implementation principles of FuAET, and then
proposes a general development process using FuAET for
reference to developers. Finally, we conduct an empirical study
for evaluation of FuAET using an industrial control application.
The results show that FuAET can automate the development of
SFSA and ease the burden of the software engineers.
Categories and Subject Descriptors
D.2.6 [Programming Environments]: Graphical environments.
General Terms
Design, Languages.
Keywords
Software fuzzy self-adaptation; Self-adaptive software; Supporting
tool; Fuzzy control
1. INTRODUCTION
Nowadays, software systems such as mobile computing systems
and complex military information systems are facing increasingly
frequent changes in their environments and user requirements. In
order to continuously ensure the required quality of service (QoS),
software is required to be self-adaptive to handle these changes,
which has made software self-adaptation become a hot research
issue [1],[2],[3],[4],[5] in the software engineering community. In
nature, software self-adaptation means that software can employ
sense-decide-act loops to sense changes from environments and
users’ requirements, decide by these sensed changes, and adjust
itself according to the decided results. However, software’
intensive interactions with environments and users imply that
there exists a lot of uncertainty in the self-adaptation loop. In most
cases, the uncertainty can be often characterized as fuzziness, e.g.,
the data inaccuracy due to the disturbance in adverse
circumstances and the vagueness of user requirements. Therefore,
how to deal with the fuzziness in self-adaptation loops of software
and realize self-adaptive software under fuzziness becomes a
challenging problem. In our previous work [6], [7], [8], borrowing
ideas from the fuzzy control community, we proposed an approach
named Software Fuzzy Self-Adaptation (SFSA), to directly model
and systematically handle fuzziness in software self-adaptation.
However, our SFSA approach encounters a problem that although
fuzzy control theory is more intelligible than other control
methods, it is still difficult to many software engineers with no
control knowledge. This highly obstructs the SFSA approach to be
applied in real world. Thus, a supporting tool is needed to bridge
the knowledge gap between the fuzzy control engineering and
software engineering and to automate the implementation process
of SFSA. Existing software tools cannot directly meet these
requirements. In the side of control engineering, although existing
commercial software tools for fuzzy control such as Fuzzy Logic
Toolbox for MATLAB
1
can edit and test fuzzy control strategies
with domain specific language (DSL), e.g., fuzzy rules, and
several tools, e.g., FuzzyTech
2
, even can convert fuzzy-rule-based
strategies into program code that can be executed in various
controllers, these software tools cannot be directly used for SFSA
because they are only designed for controlling physical plants but
not software systems. In the side of software engineering, there are
a few of good supporting tools for design and implementation of
self-adaptive software, e.g., RAIDE [9], ACT [10] and Genie [11].
However, due to less considerations of handling fuzziness in self-
adaptation loops, these tools cannot be employed to our SFSA
approach. Moreover, several pieces of current work also use fuzzy
methodology to qualitatively describe adaptation policies [12],
interpret contexts[13], and address uncertainty in requirements[14]
of self-adaptive software systems, but no effective supporting
tools can be found in them. Therefore, to the best of our
knowledge, none of existing work has explicitly presented
effective and efficient tools for handling fuzziness in loops of
software self-adaptation.
In order to improve the accessibility of software engineers to our
SFSA approach, we have built the FuAET tool to automate the
1
www.mathworks.com, September, 2014
2
www.fuzzytech.com, September, 2014
fee. Request permissions from Permissions@acm.org.