Extending UML for the Modeling of Fuzzy Self-Adaptive Software Systems Deshuai Han1, Qiliang Yang1,2, Jianchun Xing1 1. College of Defense Engineering, PLA University of Science and Technology, Nanjing 210007, China E-mail:
[email protected] 2. State Key Laboratory for Novel Software Technology, Nanjing University, Nanjing 210093, China E-mail:
[email protected] Abstract: Fuzzy self-adaptive software systems are a kind of fuzzy-control-based systems that are proposed to deal with the emerging uncertainty problem in the software self-adaptation process. The construction of such systems has shown to be significantly more challenging than traditional systems as a lack of appropriate modeling tools. To address this problem, we introduce a modeling approach, entitled Fuzzy self-Adaptation ModEling Profile (FAME Profile), which is based on the extension mechanisms of UML. FAME Profile consists of a set of new stereotypes that correspond to the key concepts within fuzzy self-adaptive software systems, and three kinds of diagrams that provide analysis view, structural view and behavioral view respectively. The FAME Profile can considerably ease the modeling of fuzzy self-adaptive software systems and can be easily incorporated into main stream UML development environments. We illustrate the complete modeling process through a fuzzy self-adaptive software system called FuzzyLon893OPCServer System. Key Words: software engineering, UML Profile, fuzzy self-adaptive software, modeling, fuzzy logic
1
INTRODUCTION
Recently, control theory has been employed by many researchers to deal with the issue of software systems. In our previous work, we proposed a new self-adaptive software paradigm called Software Fuzzy Self-Adaptation (SFSA)[1,2]. SFSA is a fuzzy-control-based self-adaptive software technology, which is proposed to deal with the emerging uncertainty problem in the self-adaptive control loop, especially the fuzzy uncertainty problem. While addressing these problems, it becomes necessary to develop so-called fuzzy self-adaptive software systems with the capability to deal autonomously with internal uncertainty, unfavorable environmental uncertainty, as well as uncertainty of requirements[2].Current approaches for developing such systems focus on the technical phase, and neglect their analysis and design phases. As a consequence, the fuzzy self-adaptive logic is not considered sufficiently early in the modeling process. We investigate some helpful experience for the modeling of fuzzy self-adaptive software systems. These studies can be categorized into two groups: tools used for the modeling of self-adaptive software systems and approaches of extending standard Unified Modeling Language (UML). Recent work provides various approaches that support the developing of self-adaptive software. In [3] the MAPE-K architecture is presented to describe abstract logical concepts for realizing adaptivity. Stitch[4] provides a language that allows the specification of adaptation concepts and can be combined with the architecture description language ACME[5] that specifies systems and contexts in formalized models. In [6] RELAX is proposed to specify the aspect of uncertainty in requirements. All these approaches can support the modeling of self-adaptive software well. However, when analyzing and designing
This work is supported by National Nature Science Foundation under Grant No. 61003019.
c 978-1-4799-3708-0/14/$31.00 2014 IEEE
fuzzy self-adaptive software systems, they lack corresponding domain specific concepts. UML has been the standard object oriented modeling language used for modeling many aspects of software systems. And it provides a set of extensibility mechanisms (stereotypes, tagged values and constraints) which are used for representing aspects of a specific domain. Several studies have investigated the extension mechanisms of UML to represent or to model self-adaptive software. In [7] Adapt Case is proposed to model self-adaptive software in the analysis and logic design phases. Stereotypes and tagged values have been added to make control loops explicit in [8]. Some works have introduced the UML extensibility mechanisms into other fields. In [9] authors presented an extension of UML for the development of context-aware applications. This profile allows context-aware concepts to be integrated with existing UML infrastructure and the extension is implemented on the StarUML software modeling platform, which gives us great inspiration. In this paper, we propose an UML profile called FAME Profile (Fuzzy self-Adaptation ModEling Profile) to support fuzzy self-adaptive system modeling process. Our approach is rooted in the SFSA conceptual framework[1], and stresses its modeling process. The FAME Profile eases the modeling of fuzzy self-adaptive software by providing a package of domain specific concepts and three packages of modeling views that support a complete modeling process. The major contributions of the FAME Profile are the following: (1) a detail description of fuzzy self-adaptive logic, (2) explicit description of the feedback loop, (3) perfect integratability with standard UML, (4) tools that support a complete modeling process of fuzzy self-adaptive software systems. In the next section we review background material. Section 3 presents the FAME Profile and provides its syntax structure and semantic description. An example application is shown in section 4 to illustrate a complete modeling process of fuzzy self-adaptive software systems.
2400
Related work is discussed in section 5 and conclusions and future work is in section 6.
2
BACKGROUND
In this section, we first provide an overview of software fuzzy self-adaptation (SFSA), and then give a brief introduction to UML and its extension mechanism.
2.1 SFSA Conceptual Framework The complexity of current software systems and uncertainty of the requirements and environments has motivated software engineering researchers to look for inspiration in diverse related fields (e.g., control theory, artificial intelligence, robotics, and biology) for new ways to design and manage systems. Software Fuzzy Self-Adaptation (SFSA)[1,2] is a fuzzy control-based technique to achieve software adaptivity and to handle the uncertainty of software. Figure 1 illustrates the conceptual framework of SFSA. It follows the classical concern-separation perspective to design the self-adaptive software system and the system is separated into two parts: fuzzy self-adaptive logic and application logic. The part of self-adaptive logic is a special expert decision system based on fuzzy logic and it follows the traditional sense-decide-act control loop. While the part of application logic meets domain specific requirements.
new created constructs. Constraints can be associated with the new defined stereotypes to extend the UML semantics. They permit to provide some conditions used as restrictions in modeling process. These constraints can be represented by using natural language or Object Constraint Language (OCL).
3
FAME PROFILE
The FAME Profile (Fuzzy self-Adaptation ModEling Profile) is designed to provide a modeling tool to help software developers to focus their attention on modeling fuzzy self-adaptive systems rather than having to define and create related concepts and notations from the scratch. As depicted in Figure 2, FAME architecture consists of four main packages. The FAME foundations package defines all basic concepts required for modeling fuzzy self-adaptive software systems. Based on these basic infrastructures, the SFSA Analysis View is created to analyze and design the processes of self-adaptive loop, the SFSA Structure View to describe the domain object classes and their specific attributes and the SFSA Behavior View to model interactions within a fuzzy self-adaptive system. FAME Profile FAME Foundations
Fuzzy Self-Adaptive Software SFSA Structure View Fuzzy Self-Adaptive Logic
SFSA Analysis View Fuzzy Roe Base
SFSA Behavior View
Fuzzification
Fuzzy Inference
Figure 2. FAME architecture model
Defuzzification
3.1 FAME Foundation Sensor
Actuator
Changes of Environment
Changes of System
Parameter
Structure
The FAME Foundations package introduces four kinds of new constructs (Fuzzy Case, Fuzzy Class, Fuzzy Association and Fuzzy Object) based on UML metaclasses, as depicted in Figure 3.
Behavior
Application Logic
To Model Application Logic
SFSA Modeling Framework
Figure 1. Conceptual framework of SFSA
Use Case
Assocaition
Class
2.2 Extension Mechanisms of UML Unified Modeling Language (UML) is a standard object oriented modeling language offered by the Object Management Group (OMG) and it is a visual language used to analyze, design, and construct many aspects of software systems. But in spite of that it cannot support all specific domain needs, so UML is designed to be extensible. UML has several features and characteristics, among which features we are interested in the extension mechanisms (stereotypes, tagged values and constraints)[10] that are used to introduce new elements for modeling specific domains such as software fuzzy self-adaptation. Stereotype can be used to create domain or platform specific terminology or notations without changing the original semantics of UML elements. Icons and symbols can be specialized to represent these new stereotypes. A tagged value is created to attach additional attribute to the
Extend
