Scenario-based Specifications Research Articles

Early analysis of requirements using NLP and Petri-nets

Scenario-based approaches are widely used for software requirements specification. Since scenarios are usually written using natural language, specifications may have statements that are ambiguous, unnecessarily complicated, missing, duplicated, or conflicting. Requirements quality is challenging since it is hard to achieve consistency in requirements products. Unfortunately, if done manually, analysis of textual scenarios can be an arduous, time-consuming, and error-prone activity. This work rethinks the unambiguity, completeness, consistency, and correctness properties of scenario-based specifications; and how static and dynamic analysis strategies could automatically evaluate them. To do so, we introduce an automated requirements analysis approach to check both structural and behavioral aspects of scenarios, which combines natural language processing, Petri-nets, and visualization techniques for: (i) identifying certain types of defects and their indicators; (ii) highlighting scenario statements or relationships among scenarios that can lead to defects; and (iii) foreseeing scenario execution paths that can lead to inconsistencies. We show the feasibility of the proposed approach through the analysis of four projects specified as scenario-based descriptions. Overall, our approach produced reasonable results, with precision greater than 89% and recall greater than 98%. Our work allows researchers, as well as practitioners, to improve the quality of scenarios through an automated analysis approach.

Improving timing analysis effectiveness for scenario-based specifications by combining SAT and LP techniques

Improving timing analysis effectiveness for scenario-based specifications by combining SAT and LP techniques

Detecting Unexpected Behaviors in Scenario-Based Specification: Asystematic Literature Review

Detecting Unexpected Behaviors in Scenario-Based Specification: Asystematic Literature Review

Quantitative Timing Analysis for Cyber-Physical Systems Using Uncertainty-Aware Scenario-Based Specifications

Due to the merits of intuitive and visual modeling of design requirements, unified modeling language (UML) sequence diagrams are widely used as scenario-based specifications in the design of cyber-physical systems (CPSs). However, when more and more CPS products are deployed within an uncertain environment, existing sequence diagram analysis approaches cannot be used to accurately capture and quantify their timing behaviors at an early design stage. To address this problem, this article extends UML sequence diagrams to allow the modeling of stochastic system inputs, message processing time, and network delays, which strongly affect the system timing behaviors. We develop a statistical model checking-based framework that can automatically convert stochastic sequence diagrams into networks of priced timed automata to enable the quantitative analysis under various performance queries. The experimental results of two industrial designs in the railway field demonstrate the effectiveness of our approach.

Efficient composition of scenario‐based hardware specifications

Complex hardware systems can be designed by breaking down their behaviour into high-level descriptions of constituent scenarios and then composing these scenarios into an efficient hardware implementation using a form of high-level synthesis. There are a few existing methodologies for such scenario-based specification and synthesis, and in this study, the authors focus on highly concurrent systems, whose scenarios are typically described using explicit concurrency models such as partial orders. They propose a new algorithm for the composition of partial order scenarios. Unlike previously published methods, the proposed algorithm supports composition constraints, which allow the designer to restrict certain aspects of the composition in order to reuse legacy intellectual property (IP). Furthermore, the authors implementation is more scalable and can cope with specifications comprising hundreds of scenarios at the cost of only of area overhead compared to optimal solutions obtained by the exhaustive search. The proposed algorithm is implemented in an open-source electronic design automation (EDA) tool, validated on a set of benchmarks, and compared to the state-of-the-art behavioural composition approaches and to other existing methodologies that make use of behavioural synthesis.

Automatic generation of predictive monitors from scenario-based specifications

ContextUnpredictability and uncertainty about future evolutions of both the system and its environment may easily compromise the behavior of the system. The subsequent software failures can have serious consequences. When dealing with open environments, run-time monitoring is one of the most promising techniques to detect software failures. Several monitoring approaches have been proposed in the last years; however, they suffer from two main limitations. First, they provide limited information to be exploited at run-time for early detecting and managing situations that most probably will lead to failures. Second, they mainly rely on logic-based specifications, whose intrinsic complexity may hamper the use of these monitoring approaches in industrial contexts. ObjectiveIn order to address these two limitations, this paper proposes a novel approach, called PREDIMO (PREDIctive MOnitoring). The approach starts from scenario-based specifications, automatically generates predictive monitors called MAs (Multi-valued Automata), which take into account the actual status and also the possible evolution of both system and environment in the near future, and enables the definition of precise strategies to prevent failures. More specifically, the generated monitors evaluate the specified properties and return one of the seven different values representing the degree of controllability of the system and the distance of the potential incoming failure. The translation from scenario-based specifications to MAs preserves the semantics of the starting specification. MethodWe use the design and creation research methodology to design an innovative approach that fills highlighted gaps of state-of-the-art approaches. The validation of the approach is performed through a large experimentation with OSGi (Open Service Gateway Initiative) applications. ResultsWe present a novel language to specify the properties to be monitored. Then, we present a novel approach to automatically generate predictive monitors from the specified properties. ConclusionThe overall approach is tool supported and a large experimentation demonstrates its feasibility and usability.

Android-SRV: Scenario-Based Runtime Verification of Android Applications

With the wide-spread usage of Android systems, Android applications have become the target of mobile malwares. Therefore, an effective verification approach for Android applications is essential. Runtime verification based on monitors is one of the most promising techniques to check the software’s behaviors. Currently, there are a number of monitoring approaches for Android applications. However, these approaches mainly have two limitations. First, there is no effective mechanism to reduce the load on Android applications caused by monitors. Second, these approaches mainly rely on logic-based specifications, which are complex and not intuitive for being used in practice. In order to address these two limitations, this paper proposes a scenario-based runtime verification approach for Android applications (called Android-SRV). The approach concentrates on providing a dynamic and usable solution for monitoring applications during execution with the help of aspect-oriented programming. It will translate the scenario-based specification (called property sequence charts (PSCs)) into multi-valued automata (MAs), and then generate AspectJ codes from the MA. Finally, these AspectJ codes are weaved into the target system as monitors. Considering the impact of the monitors on performance load in the Android system, the paper proposes local and cloud collaboration mechanisms to reduce the impact. The scenario-based specification is more intuitive than the traditional logic-based specifications. The approach is shown to be an effective means for monitoring Android applications with controlled overload.

Generating Correct, Compact, and Efficient PLC Code from Scenario-based Assume-Guarantee Specifications

Cyber-physical systems can be found in many areas, e.g., manufacturing, health care or smart cities. They consist of many distributed components cooperating to provide increasingly complex functionality. The design and development of such a system is difficult and error-prone. To help engineers overcome these challenges we created a formal, scenario-based specification language. Short scenarios, i.e., event sequences, specify requirements and the desired behaviors by describing how components may, must, or must not behave. Scenarios provide an intuitive way for creating formal assume-guarantee (GR(1)) specifications, giving engineers easy access to simulation, for validating the specified behavior, and controller synthesis, for creating controller software which is correct by construction. In this paper we present an approach for generating Programmable Logic Controller (PLC) code from a scenario-based specification. Previous code generation efforts, including our own, created large, verbose source files causing some tools, e.g., compilers or editors, to perform slowly or even become unresponsive. Our new approach creates compact files, shifting significant amounts of code from executable instructions to data, to reduce the burden on the compiler and other tools. The generated code is efficient and introduces minimal to no latency between the occurrence of an event and the system’s reaction to it.

Distributed Execution of Scenario-based Specifications of Structurally Dynamic Cyber-Physical Systems

Cyber-physical systems are found in many areas, e.g., manufacturing or smart cities. They consist of multiple components that cooperate to provide the desired functionality. This need for cooperation causes complex interactions between components, which makes developing cyber-physical systems difficult, especially systems whose component structure changes dynamically at runtime. We have created a formal, scenario-based specification method which makes it easier to develop distributed cyber-physical systems. We previously presented an approach for the distributed execution of such specifications based on naive and inefficient broadcasting. In this paper we propose a more efficient approach which uses the available network resources more economically.

Checking conformance for time-constrained scenario-based specifications

We consider the problem of model checking message-passing systems with real-time requirements. As behavioral specifications, we use message sequence charts (MSCs) annotated with timing constraints. Our system model is a network of communicating finite state machines with local clocks, whose global behavior can be regarded as a timed automaton. Our goal is to verify that all timed behaviors exhibited by the system conform to the timing constraints imposed by the specification. In general, this corresponds to checking inclusion for timed languages, which is an undecidable problem even for timed regular languages. However, we show that we can translate regular collections of time-constrained MSCs into a special class of event-clock automata that can be determinized and complemented, thus permitting an algorithmic solution to the model checking/conformance problem.

Verification of lack of emergent behavior in extending a social network of agents

The scalability of the system is of vital importance in the design of social networks. This research attempts to establish a comprehensive framework for analysis and validation of requirements and design documents for software systems. In previous work, we applied this framework to analyze the requirements of a social network of agents with respect to scalability of the system. In our approach, system requirements were expressed using scenario-based specifications. Scenarios are appealing because of their expressive power and simplicity. Moreover, due to the clear and concise notation of scenarios, they can be used to analyze the system requirements for general validity, lack of deadlock, and existence of emergent behavior. In this paper a methodology is presented to formally verify that certain scenarios do not emerge in the system’s behavior. This methodology is devised to indicate whether or not the new requirements of the system are consistent with the current requirements in place. A larger prototype of a social network of MSA for semantic search is utilized to illustrate the developed methodology.

���������� ������������ ����� ����� ��� ����������� �������������� ������, ����������������� MSC-�����������

The language of message sequence charts (MSC) is a popular scenario-based specification language used to describe the interaction of components in distributed systems. However, the methods for validation of MSC diagrams are underdeveloped. This paper describes a method for translation of MSC diagrams into coloured Petri nets (CPN). The method is applied to the property verification of these diagrams. The considered set of diagram elements is extended by the elements of UML sequence diagrams and compositional MSC diagrams. The properties of the resulting CPN are analyzed and verified using the known system CPN Tools and the CPN verifier based on the SPIN tool. The application of this method is illustrated with an example.

基于博弈论的开放环境下场景规约监控语义

In open environments, unsafe run-time changes of systems and environments may compromise the correct execution of the entire systems and make the software systems do not meet the original specifications, which may eventually lead to the occurrence of software failures. Runtime monitor which is a lightweight formal dynamic verification technology has become the basic means of detecting software failures in open environments. For scenario-based specification property sequence charts, this paper defines the multi-valued monitoring semantics from the perspective of game theory: satisfied, infinitely controllable, the system is finitely controllable, the system is emergency controllable, the environment is finitely controllable, the environment is emergency controllable, violated. Through the multi-valued semantics definition, the monitor can detect failures as early as possible and also provide sufficient information to help the system to take measures for failure prevention and recovery. Finally, the property sequence chart used in RailCab case study shows its extensive application prospect.

Towards Synthesizing Energy-efficient Controllers for Modern Production Systems from Scenario-based Specifications

Abstract Due to continuously rising electricity prices, the energy efficiency of production systems is an increasingly important factor in industrial manufacturing. One goal is therefore to reuse the braking energy of manipulator axes. The acceleration and deceleration phases of axes must be synchronized such that, ideally, the braking energy can be reused immediately within the system. In our current technique for the energy-efficient motion planning of concurrent movements of axes, we do not yet consider changing the discrete control logic to reorder movement sequences. This is difficult, since this reordering must not violate critical system requirements. In this paper, we outline a new technique for automatically synthesizing energy-efficient discrete controllers from a scenario-based specification of a production system, which we enrich with information about consumed and generated energy. Last, we provide an outlook on challenging open research problems.

Web services property sequence chart monitor: a tool chain for monitoring BPEL‐based web service composition with scenario‐based specifications

Web service composition is a new paradigm to develop distributed and reactive software-intensive systems. Owing to the autonomous nature of basic services, the validation of composite service must be extended from design-time to run-time. Here, the authors describe a novel tool chain called web services property sequence chart monitor to monitor temporal, timing and probabilistic properties in composite service based on scenario-based property specifications called property sequence chart, timed property sequence chart and probabilistic timed property sequence chart, respectively. The tool chain provides a completely graphical front-end that eliminates the need to deal with any particular textual and logical formalism. Furthermore, the framework and implementation detail of the tool chain are also presented. Finally, the feasibility and usability of the tool have been validated by the case studies and performance measurement.

Synthesizing Modal Transition Systems from Triggered Scenarios

Synthesis of operational behavior models from scenario-based specifications has been extensively studied. The focus has been mainly on either existential or universal interpretations. One noteworthy exception is Live Sequence Charts (LSCs), which provides expressive constructs for conditional universal scenarios and some limited support for nonconditional existential scenarios. In this paper, we propose a scenario-based language that supports both existential and universal interpretations for conditional scenarios. Existing model synthesis techniques use traditional two-valued behavior models, such as Labeled Transition Systems. These are not sufficiently expressive to accommodate specification languages with both existential and universal scenarios. We therefore shift the target of synthesis to Modal Transition Systems (MTS), an extension of labeled Transition Systems that can distinguish between required, unknown, and proscribed behavior to capture the semantics of existential and universal scenarios. Modal Transition Systems support elaboration of behavior models through refinement, which complements an incremental elicitation process suitable for specifying behavior with scenario-based notations. The synthesis algorithm that we define constructs a Modal Transition System that uses refinement to characterize all the Labeled Transition Systems models that satisfy a mixed, conditional existential and universal scenario-based specification. We show how this combination of scenario language, synthesis, and Modal Transition Systems supports behavior model elaboration.

Features meet scenarios: modeling and consistency-checking scenario-based product line specifications

Many modern software-intensive systems consist of multiple components interacting together to deliver the intended functionality. Often, these systems come in many variants (products) and are managed together as a software product line. This variability is the source of additional complexity which can cause inconsistencies and offset the economies of scale promised by product line engineering. Engineers thus need intuitive, yet precise means for specifying requirements and require tools for automatically detecting inconsistencies within these requirements. In recent work, we proposed a technique for the scenario-based specification of interactions in product lines by a combination of Modal Sequence Diagrams and Feature Diagrams. Furthermore, we elaborated an efficient consistency-checking technique based on a dedicated model-checking approach especially tailored for product lines. In this paper, we report on further evaluations that underline significant performance benefits of our approach. We describe further optimizations and detail on how we encode the consistency-checking problem for a model-checker.

COMPARING AND IMPROVING THE SYNTHESIS OF STATE-BASED SPECIFICATIONS FROM SCENARIO-BASED SPECIFICATIONS

The scenario-based specifications are popularly used to capture user requirements. The state-based specifications are very appropriate to capture system design. Recently, there has been increased research interest in connecting these two kinds of specifications, called synthesis. Synthesis is a way to automatically construct the state-based specifications from the scenario-based specifications. There are two kinds of synthesis methods: global synthesis and local synthesis. Global synthesis means constructing a state-based specification for the whole system from the scenario-based specifications, while local synthesis means constructing a state-based specification for each object in the system. The two different synthesis methods have different uses and need to be systematically compared. The contributions of this paper are twofold. Firstly, we propose an improved method supporting the global and the local synthesis of state machines (a kind of state-based specifications) by using a novel algorithm for state machine execution and an algorithm similar to operator priority analysis method, which can fully automate the process of synthesis. Our synthesis method also satisfies two important properties: completeness and soundness. Secondly, to the best of our knowledge, our work does the first attempt to systematically compare global synthesis with local synthesis, and shows some insightful results of the experimental comparison between the two kinds of synthesis methods, which are valuable for the practitioners to choose an appropriate synthesis method for the analysis and verification of the system.

DETECTING EMERGENT BEHAVIOR IN DISTRIBUTED SYSTEMS USING SCENARIO-BASED SPECIFICATIONS

Emergent behavior is an important issue in distributed systems' design. Detecting and removing emergent behavior during the design phase will lead to huge savings in deployment costs of such systems. An effective approach for the design of distributed systems is to describe system requirements using scenarios. A scenario, commonly known as a message sequence chart or a sequence diagram, is a temporal sequence of messages sent between system components. However, scenario-based specifications are prone to subtle deficiencies with respect to analysis and validation known as incompleteness and partial description. In this research, a method for detecting emergent behavior of scenario-based specification is proposed. The method is demonstrated and verified using a mine-sweeping robot as an example. Furthermore it has been demonstrated in this paper that scenario-based specifications can be used in agile software development and that the proposed methodologies in this research can be utilized effectively in agile approaches.

Strongly consistent transformation of partial scenarios

We present a formal approach for partial transformation of scenario-based specifications. Scenarios are captured as sequence diagrams (SDs) and (partially) transformed into coloured Petri nets (CPNs). Partial transformation is of interest for local analysis, or within an incremental development approach where interaction specifications are built incrementally and combined with previous iteration models. In previous work we defined a strongly consistent trans- formation from SDs to CPNs. In this paper, we extend the approach for partial transformation whilst preserving the strongly consistent nature of the transformation.