Deshuai Han

FAME: A UML-based framework for modeling fuzzy self-adaptive software

Abstract Context: Software Fuzzy Self-Adaptation (SFSA) is a fuzzy control-based software self-adaptation paradigm proposed to deal with the fuzzy uncertainty existing in self-adaptive software. However, as many software engineers lack fuzzy control knowledge, it is difficult for them to design and model this kind of fuzzy self-adaptive software (F-SAS). Therefore, efficient and effective modeling technologies and tools are needed for the SFSA framework. Objective: This paper aims to identify modeling requirements of F-SAS and to provide a modeling framework to specify, design and model F-SAS systems. Such a framework can simplify modeling process of F-SAS and improve the accessibility of software engineers to the SFSA paradigm. Method: This study proposes a modeling framework called Fuzzy self-Adaptation ModEling (FAME). By extending UML, FAME creates three types of modeling views. An analysis view called Fuzzy Case Diagram is created to specify the fuzzy self-adaptation goal and the realization processes of this goal. A structure view called Fuzzy Class Diagram is created to describe the fuzzy concepts and structural characteristics of F-SAS. A behavior view called Fuzzy Sequence Diagram is created to depict the dynamic behaviors of the F-SAS systems. The framework is implemented as a plug-in of Enterprise Architect. Results: We demonstrate the effectiveness and efficiency of the proposed approach by carrying out a subject-based empirical evaluation. The results show that FAME framework can improve modeling quality of F-SAS systems by 44.38% and shorten modeling time of F-SAS systems by 38.41% in comparison with traditional UML. Thus, FAME can considerably ease the modeling process of F-SAS systems. Conclusion: FAME framework incorporates the SFSA concepts into standard UML. Therefore, it provides a direct support to model SFSA characteristics and improves the accessibility of software engineers to the SFSA paradigm. Furthermore, it behaves a good example and provides good references for modeling domain-specific software systems.

Extending UML for the modeling of fuzzy self-adaptive software systems

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.

Handling Uncertainty in Self-Adaptive Software Using Self-Learning Fuzzy Neural Network

Uncertainty has posed great challenges to the development and application of self-adaptive software (SAS). To handle uncertainty underneath SAS, the technique of fuzzy control method has been employed to model and develop SASs. Practices prove that fuzzy logic is powerful to handle uncertainty, especially fuzzy uncertainty, within SAS. However, fuzzy control based SAS needs software developers to set fuzzy rules of the system, which is rather experience-dependent and heavily increases development burden of software engineers. To some extent, the effect of handling uncertainty depends on experiences of software engineers. Besides, fuzzy control based SAS realizes self-adaptation logic using fixed fuzzy rules, lacking the ability to adapt to large changes (e.g., scenario switches). In order to make up the above shortages of fuzzy control based SAS, we present the Fuzzy-Learning SAS, attempting to construct self-adaptation logic using self-learning fuzzy neural network. By incorporating the model of fuzzy neural network, Fuzzy-Learning models SAS with two feedback loops, i.e., the self-adaptation loop and the self-learning loop, enabling SASs with the ability of adapting to dynamic changes and the ability of automatically constructing self-adaptation logic. We have experimentally evaluated effectiveness and efficiency of Fuzzy-Learning SAS with a motivating example. The experiment results confirmed that Fuzzy-Learning SAS can improve the effect of handling uncertainty and alleviate the development burden of software engineers with ill knowledge of fuzzy control. Besides, Fuzzy-Learning SAS can adapt to large changes (e.g., scenario switches) with the self-learning ability.

Recognizing Voice-Based Requirements to Drive Self-Adaptive Software Systems

Traditional self-adaptive systems controlled by text-command and manual operations are slow and inefficient. However, with the rapid advances in the field of Voice Recognition, systems are easy to capture command and react to users requirements. Voice-facilities are expected to enhance the ability and performance of systems. In this paper, we argue how to incorporate voice-based requirements into self-adaptive systems, and to propose the framework of voice-based software fuzzy self-adaptation (V-SFSA) with fuzzy control-based method, attempting to handling ambiguity and implicitness in requirements underneath self-adaptive systems. Besides, we present a general implementation process to realize V-SFSA. Based on the platform of Turtlebot2, we construct the VoiceGuider system to validate our framework and approach, and the experiment results confirmed that V-SFSA can effectively recognize and handle voice-based fuzzy requirements (i.e. ambiguous and implicit requirements) within self-adaptive systems.

Formal Sequence: Extending UML Sequence Diagram for Behavior Description and Formal Verification

The Unified Modeling Language (UML) is rapidly emerging as a de-facto standard used for software specifications and UML sequence diagrams provide a visual technique to model and depict software behaviors. However, sequence diagrams cannot automatically analyze and verify software behaviors due to lack of strict semantics. To ensure the reliability of software systems, a behavior description and formal verification approach called formal sequence is proposed in this paper, which integrates extended UML sequence diagram and automata model. Firstly, sequence diagram is extended and formally defined into a two-dimensional diagram called SD2D. Then, a full-map relationship is established between SD2D and the timed automata network (TAN). Thirdly, on basis of the above mapping relationships, the model transformation approach is established, realizing the transformation from SD2D to TAN. Formal verification can be then carried out to check domain specific properties with automated model checkers like UPPAAL. Our proposed approach realizes a full-map from sequence diagram to TAN and bridges the gap between visual modeling and formal modeling of software. Experimental results show that the proposed approach of formal sequence is effective and efficient in behavior description and formal verification of software.

Modification Impact Analysis Based Test Case Prioritization for Regression Testing of Service-Oriented Workflow Applications

Test case prioritization for regression testing is an approach that schedules test cases to improve the efficiency of service-oriented workflow application testing. Most of existing prioritization approaches range test cases according to various metrics (e.g., Statement coverage, path coverage) in different application context. Service-oriented workflow applications orchestrate web services to provide value-added service and typically are long-running and time-consuming processes. Therefore, these applications need more precise prioritization to execute earlier those test cases that may detect failures. Surprisingly, most of current regression test case prioritization researches neglect to use internal structure information of software, which is a significant factor influencing the prioritization of test cases. Considering the internal structure information and fault propagation behavior of modifications respect to modified version for service-oriented workflow applications, we present in this paper a new regression test case prioritization approach. Our prioritization approach schedules test cases based on dependence analysis of internal activities in service-oriented workflow applications. Experimental results show that test case prioritization using our approach is more effective than conventional coverage-based techniques.

A Similarity-Based Approach to Recognizing Voice-Based Task Goals in Self-Adaptive Systems

With the development of the natural language processing (NLP) technologies, users tend to directly input their goals via natural language to a task system. Thus, how to input informal voice-based task goals to self-adaptive systems (SASs) has become a challenge issue. Our previously proposed framework V-SFSA (voice-driven software fuzzy self-adaptation) can realize to input voice-based task goals to SAS. However, it still suffers from low efficiency of recognition. In this paper, in order to improve on our previous V-SFSA framework, we propose a similarity-based NLP approach to recognizing the voice-based task goals in SASs. It uses the verb of the raw voice inputs to preselect the semantic relevant commands, and then to compute the similarity between the preselected commands and predefined featured commands in a SAS. The command with the highest similarity score is accepted as the intended goals to drive a SAS. We establish the improved V-SFSA, and implement the algorithm of similarity-based fuzzy adaptation. In addition, we construct a prototype to conduct a case study. The result shows that our approach is effective.

Integrating Goal Models and Problem Frames for Requirements Analysis of Self-Adaptive CPS

As Cyber-Physical Systems (CPS) operate in open, dynamic and diverse environments, they need to be self-adaptive to address the uncertainty challenges. And it is urgent to study self-adaptive software intensive Cyber-Physical Systems (self-adaptive CPS). As self-adaptive CPS interact closely with the environments and users, their requirements analysis is particularly challenging. General requirement models (e.g., goal models and problem frames) of CPS or self-adaptive software cannot be directly applied to self-adaptive CPS. In this paper, we present the Adapt-Requirement Model, which integrates goal models and problem frames, and further extends both models with self-adaptive CPS concepts. The integrated approach incorporates advantages of both goal models and problem frames, and can specify adaptation objectives of stakeholders as well as dynamic contexts of the system. Moreover, we create a UML Profile to represent Adapt-Requirement Model, and create a supporting tool for it. The UML profile and supporting tool has established continuity and integratability between Adapt-Requirement Model and UML design models. The applicability of our approach is illustrated using an example of Smart Building Firefighting System.

Optimal control based regression test selection for service-oriented workflow applications

Regression test selection problem is treated as an optimal control issue.Three rules are given to transform BPEL application into an universal BPEL form.Our approach can select fewer test cases to test BPEL applications effectively.We prove our optimal control strategy is safe under controlled regression testing. Regression test selection, which is well known as an effective technology to ensure the quality of modified BPEL applications, is regarded as an optimal control issue. The BPEL applications under test serves as a controlled object and the regression test selection strategy functions as the corresponding controller. The performance index is to select fewest test cases to test modified BPEL applications. In addition, a promising controller (regression test selection approach) should be safe, which means that it can select all test cases in which faults might be exposed in modified versions under controlled regression testing from the original test suite. However, existing safe controllers may rerun some test cases without exposing fault. In addition, the unique features (e.g., dead path elimination semantics, communication mechanism, multi-assignment etc.) of BPEL applications also raise enormous problems in regression test selection. To address these issues, we present in this paper a safe optimal controller for BPEL applications. Firstly, to handle the unique features mentioned above, we transform BPEL applications and their modified versions into universal BPEL forms. Secondly, For our optimal controller, BPEL program dependence graphs corresponding to the two universal BPEL forms are established. Finally, guided by behavioral differences between the two versions, we construct an optimal controller and select test cases to be rerun. By contrast with the previous approaches, our approach can eliminate some unnecessary test cases to be selected. We conducted experiments with 8 BPEL applications to compare our approach with other typical approaches. Experimental results show that the test cases selected using our approach are fewer than other approaches.